Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessDeniedException

type AccessDeniedException struct {
	Message *string
}

    Access to a resource was denied.

    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 Action

    type Action struct {
    
    	// The job arguments used when this trigger fires. For this job run, they replace
    	// the default arguments set in the job definition itself. You can specify
    	// arguments here that your own job-execution script consumes, as well as arguments
    	// that AWS Glue itself consumes. For information about how to specify and consume
    	// your own Job arguments, see the Calling AWS Glue APIs in Python
    	// (https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-calling.html)
    	// topic in the developer guide. For information about the key-value pairs that AWS
    	// Glue consumes to set up your job, see the Special Parameters Used by AWS Glue
    	// (https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html)
    	// topic in the developer guide.
    	Arguments map[string]string
    
    	// The name of the crawler to be used with this action.
    	CrawlerName *string
    
    	// The name of a job to be executed.
    	JobName *string
    
    	// Specifies configuration properties of a job run notification.
    	NotificationProperty *NotificationProperty
    
    	// The name of the SecurityConfiguration structure to be used with this action.
    	SecurityConfiguration *string
    
    	// The JobRun timeout in minutes. This is the maximum time that a job run can
    	// consume resources before it is terminated and enters TIMEOUT status. The default
    	// is 2,880 minutes (48 hours). This overrides the timeout value set in the parent
    	// job.
    	Timeout *int32
    }

      Defines an action to be initiated by a trigger.

      type AlreadyExistsException

      type AlreadyExistsException struct {
      	Message *string
      }

        A resource to be created or added already exists.

        func (*AlreadyExistsException) Error

        func (e *AlreadyExistsException) Error() string

        func (*AlreadyExistsException) ErrorCode

        func (e *AlreadyExistsException) ErrorCode() string

        func (*AlreadyExistsException) ErrorFault

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

        func (*AlreadyExistsException) ErrorMessage

        func (e *AlreadyExistsException) ErrorMessage() string

        type BackfillError

        type BackfillError struct {
        
        	// The error code for an error that occurred when registering partition indexes for
        	// an existing table.
        	Code BackfillErrorCode
        
        	// A list of a limited number of partitions in the response.
        	Partitions []PartitionValueList
        }

          A list of errors that can occur when registering partition indexes for an existing table. These errors give the details about why an index registration failed and provide a limited number of partitions in the response, so that you can fix the partitions at fault and try registering the index again. The most common set of errors that can occur are categorized as follows:

          * EncryptedPartitionError: The partitions are encrypted.

          * InvalidPartitionTypeDataError: The partition value doesn't match the data type for that partition column.

          * MissingPartitionValueError: The partitions are encrypted.

          * UnsupportedPartitionCharacterError: Characters inside the partition value are not supported. For example: U+0000 , U+0001, U+0002.

          * InternalError: Any error which does not belong to other error codes.

          type BackfillErrorCode

          type BackfillErrorCode string
          const (
          	BackfillErrorCodeEncryptedPartitionError            BackfillErrorCode = "ENCRYPTED_PARTITION_ERROR"
          	BackfillErrorCodeInternalError                      BackfillErrorCode = "INTERNAL_ERROR"
          	BackfillErrorCodeInvalidPartitionTypeDataError      BackfillErrorCode = "INVALID_PARTITION_TYPE_DATA_ERROR"
          	BackfillErrorCodeMissingPartitionValueError         BackfillErrorCode = "MISSING_PARTITION_VALUE_ERROR"
          	BackfillErrorCodeUnsupportedPartitionCharacterError BackfillErrorCode = "UNSUPPORTED_PARTITION_CHARACTER_ERROR"
          )

            Enum values for BackfillErrorCode

            func (BackfillErrorCode) Values

              Values returns all known values for BackfillErrorCode. 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 BatchStopJobRunError

              type BatchStopJobRunError struct {
              
              	// Specifies details about the error that was encountered.
              	ErrorDetail *ErrorDetail
              
              	// The name of the job definition that is used in the job run in question.
              	JobName *string
              
              	// The JobRunId of the job run in question.
              	JobRunId *string
              }

                Records an error that occurred when attempting to stop a specified job run.

                type BatchStopJobRunSuccessfulSubmission

                type BatchStopJobRunSuccessfulSubmission struct {
                
                	// The name of the job definition used in the job run that was stopped.
                	JobName *string
                
                	// The JobRunId of the job run that was stopped.
                	JobRunId *string
                }

                  Records a successful request to stop a specified JobRun.

                  type BatchUpdatePartitionFailureEntry

                  type BatchUpdatePartitionFailureEntry struct {
                  
                  	// The details about the batch update partition error.
                  	ErrorDetail *ErrorDetail
                  
                  	// A list of values defining the partitions.
                  	PartitionValueList []string
                  }

                    Contains information about a batch update partition error.

                    type BatchUpdatePartitionRequestEntry

                    type BatchUpdatePartitionRequestEntry struct {
                    
                    	// The structure used to update a partition.
                    	//
                    	// This member is required.
                    	PartitionInput *PartitionInput
                    
                    	// A list of values defining the partitions.
                    	//
                    	// This member is required.
                    	PartitionValueList []string
                    }

                      A structure that contains the values and structure used to update a partition.

                      type BinaryColumnStatisticsData

                      type BinaryColumnStatisticsData struct {
                      
                      	// The average bit sequence length in the column.
                      	//
                      	// This member is required.
                      	AverageLength float64
                      
                      	// The size of the longest bit sequence in the column.
                      	//
                      	// This member is required.
                      	MaximumLength int64
                      
                      	// The number of null values in the column.
                      	//
                      	// This member is required.
                      	NumberOfNulls int64
                      }

                        Defines column statistics supported for bit sequence data values.

                        type BooleanColumnStatisticsData

                        type BooleanColumnStatisticsData struct {
                        
                        	// The number of false values in the column.
                        	//
                        	// This member is required.
                        	NumberOfFalses int64
                        
                        	// The number of null values in the column.
                        	//
                        	// This member is required.
                        	NumberOfNulls int64
                        
                        	// The number of true values in the column.
                        	//
                        	// This member is required.
                        	NumberOfTrues int64
                        }

                          Defines column statistics supported for Boolean data columns.

                          type CatalogEncryptionMode

                          type CatalogEncryptionMode string
                          const (
                          	CatalogEncryptionModeDisabled CatalogEncryptionMode = "DISABLED"
                          	CatalogEncryptionModeSsekms   CatalogEncryptionMode = "SSE-KMS"
                          )

                            Enum values for CatalogEncryptionMode

                            func (CatalogEncryptionMode) Values

                              Values returns all known values for CatalogEncryptionMode. 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 CatalogEntry

                              type CatalogEntry struct {
                              
                              	// The database in which the table metadata resides.
                              	//
                              	// This member is required.
                              	DatabaseName *string
                              
                              	// The name of the table in question.
                              	//
                              	// This member is required.
                              	TableName *string
                              }

                                Specifies a table definition in the AWS Glue Data Catalog.

                                type CatalogImportStatus

                                type CatalogImportStatus struct {
                                
                                	// True if the migration has completed, or False otherwise.
                                	ImportCompleted bool
                                
                                	// The time that the migration was started.
                                	ImportTime *time.Time
                                
                                	// The name of the person who initiated the migration.
                                	ImportedBy *string
                                }

                                  A structure containing migration status information.

                                  type CatalogTarget

                                  type CatalogTarget struct {
                                  
                                  	// The name of the database to be synchronized.
                                  	//
                                  	// This member is required.
                                  	DatabaseName *string
                                  
                                  	// A list of the tables to be synchronized.
                                  	//
                                  	// This member is required.
                                  	Tables []string
                                  }

                                    Specifies an AWS Glue Data Catalog target.

                                    type Classifier

                                    type Classifier struct {
                                    
                                    	// A classifier for comma-separated values (CSV).
                                    	CsvClassifier *CsvClassifier
                                    
                                    	// A classifier that uses grok.
                                    	GrokClassifier *GrokClassifier
                                    
                                    	// A classifier for JSON content.
                                    	JsonClassifier *JsonClassifier
                                    
                                    	// A classifier for XML content.
                                    	XMLClassifier *XMLClassifier
                                    }

                                      Classifiers are triggered during a crawl task. A classifier checks whether a given file is in a format it can handle. If it is, the classifier creates a schema in the form of a StructType object that matches that data format. You can use the standard classifiers that AWS Glue provides, or you can write your own classifiers to best categorize your data sources and specify the appropriate schemas to use for them. A classifier can be a grok classifier, an XML classifier, a JSON classifier, or a custom CSV classifier, as specified in one of the fields in the Classifier object.

                                      type CloudWatchEncryption

                                      type CloudWatchEncryption struct {
                                      
                                      	// The encryption mode to use for CloudWatch data.
                                      	CloudWatchEncryptionMode CloudWatchEncryptionMode
                                      
                                      	// The Amazon Resource Name (ARN) of the KMS key to be used to encrypt the data.
                                      	KmsKeyArn *string
                                      }

                                        Specifies how Amazon CloudWatch data should be encrypted.

                                        type CloudWatchEncryptionMode

                                        type CloudWatchEncryptionMode string
                                        const (
                                        	CloudWatchEncryptionModeDisabled CloudWatchEncryptionMode = "DISABLED"
                                        	CloudWatchEncryptionModeSsekms   CloudWatchEncryptionMode = "SSE-KMS"
                                        )

                                          Enum values for CloudWatchEncryptionMode

                                          func (CloudWatchEncryptionMode) Values

                                            Values returns all known values for CloudWatchEncryptionMode. 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 CodeGenEdge

                                            type CodeGenEdge struct {
                                            
                                            	// The ID of the node at which the edge starts.
                                            	//
                                            	// This member is required.
                                            	Source *string
                                            
                                            	// The ID of the node at which the edge ends.
                                            	//
                                            	// This member is required.
                                            	Target *string
                                            
                                            	// The target of the edge.
                                            	TargetParameter *string
                                            }

                                              Represents a directional edge in a directed acyclic graph (DAG).

                                              type CodeGenNode

                                              type CodeGenNode struct {
                                              
                                              	// Properties of the node, in the form of name-value pairs.
                                              	//
                                              	// This member is required.
                                              	Args []CodeGenNodeArg
                                              
                                              	// A node identifier that is unique within the node's graph.
                                              	//
                                              	// This member is required.
                                              	Id *string
                                              
                                              	// The type of node that this is.
                                              	//
                                              	// This member is required.
                                              	NodeType *string
                                              
                                              	// The line number of the node.
                                              	LineNumber int32
                                              }

                                                Represents a node in a directed acyclic graph (DAG)

                                                type CodeGenNodeArg

                                                type CodeGenNodeArg struct {
                                                
                                                	// The name of the argument or property.
                                                	//
                                                	// This member is required.
                                                	Name *string
                                                
                                                	// The value of the argument or property.
                                                	//
                                                	// This member is required.
                                                	Value *string
                                                
                                                	// True if the value is used as a parameter.
                                                	Param bool
                                                }

                                                  An argument or property of a node.

                                                  type Column

                                                  type Column struct {
                                                  
                                                  	// The name of the Column.
                                                  	//
                                                  	// This member is required.
                                                  	Name *string
                                                  
                                                  	// A free-form text comment.
                                                  	Comment *string
                                                  
                                                  	// These key-value pairs define properties associated with the column.
                                                  	Parameters map[string]string
                                                  
                                                  	// The data type of the Column.
                                                  	Type *string
                                                  }

                                                    A column in a Table.

                                                    type ColumnError

                                                    type ColumnError struct {
                                                    
                                                    	// The name of the column that failed.
                                                    	ColumnName *string
                                                    
                                                    	// An error message with the reason for the failure of an operation.
                                                    	Error *ErrorDetail
                                                    }

                                                      Encapsulates a column name that failed and the reason for failure.

                                                      type ColumnImportance

                                                      type ColumnImportance struct {
                                                      	ColumnName *string
                                                      
                                                      	Importance *float64
                                                      }

                                                      type ColumnStatistics

                                                      type ColumnStatistics struct {
                                                      
                                                      	// The timestamp of when column statistics were generated.
                                                      	//
                                                      	// This member is required.
                                                      	AnalyzedTime *time.Time
                                                      
                                                      	// Name of column which statistics belong to.
                                                      	//
                                                      	// This member is required.
                                                      	ColumnName *string
                                                      
                                                      	// The data type of the column.
                                                      	//
                                                      	// This member is required.
                                                      	ColumnType *string
                                                      
                                                      	// A ColumnStatisticData object that contains the statistics data values.
                                                      	//
                                                      	// This member is required.
                                                      	StatisticsData *ColumnStatisticsData
                                                      }

                                                        Represents the generated column-level statistics for a table or partition.

                                                        type ColumnStatisticsData

                                                        type ColumnStatisticsData struct {
                                                        
                                                        	// The type of column statistics data.
                                                        	//
                                                        	// This member is required.
                                                        	Type ColumnStatisticsType
                                                        
                                                        	// Binary column statistics data.
                                                        	BinaryColumnStatisticsData *BinaryColumnStatisticsData
                                                        
                                                        	// Boolean column statistics data.
                                                        	BooleanColumnStatisticsData *BooleanColumnStatisticsData
                                                        
                                                        	// Date column statistics data.
                                                        	DateColumnStatisticsData *DateColumnStatisticsData
                                                        
                                                        	// Decimal column statistics data.
                                                        	DecimalColumnStatisticsData *DecimalColumnStatisticsData
                                                        
                                                        	// Double column statistics data.
                                                        	DoubleColumnStatisticsData *DoubleColumnStatisticsData
                                                        
                                                        	// Long column statistics data.
                                                        	LongColumnStatisticsData *LongColumnStatisticsData
                                                        
                                                        	// String column statistics data.
                                                        	StringColumnStatisticsData *StringColumnStatisticsData
                                                        }

                                                          Contains the individual types of column statistics data. Only one data object should be set and indicated by the Type attribute.

                                                          type ColumnStatisticsError

                                                          type ColumnStatisticsError struct {
                                                          
                                                          	// The ColumnStatistics of the column.
                                                          	ColumnStatistics *ColumnStatistics
                                                          
                                                          	// An error message with the reason for the failure of an operation.
                                                          	Error *ErrorDetail
                                                          }

                                                            Encapsulates a ColumnStatistics object that failed and the reason for failure.

                                                            type ColumnStatisticsType

                                                            type ColumnStatisticsType string
                                                            const (
                                                            	ColumnStatisticsTypeBoolean ColumnStatisticsType = "BOOLEAN"
                                                            	ColumnStatisticsTypeDate    ColumnStatisticsType = "DATE"
                                                            	ColumnStatisticsTypeDecimal ColumnStatisticsType = "DECIMAL"
                                                            	ColumnStatisticsTypeDouble  ColumnStatisticsType = "DOUBLE"
                                                            	ColumnStatisticsTypeLong    ColumnStatisticsType = "LONG"
                                                            	ColumnStatisticsTypeString  ColumnStatisticsType = "STRING"
                                                            	ColumnStatisticsTypeBinary  ColumnStatisticsType = "BINARY"
                                                            )

                                                              Enum values for ColumnStatisticsType

                                                              func (ColumnStatisticsType) Values

                                                                Values returns all known values for ColumnStatisticsType. 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 Comparator

                                                                type Comparator string
                                                                const (
                                                                	ComparatorEquals            Comparator = "EQUALS"
                                                                	ComparatorGreaterThan       Comparator = "GREATER_THAN"
                                                                	ComparatorLessThan          Comparator = "LESS_THAN"
                                                                	ComparatorGreaterThanEquals Comparator = "GREATER_THAN_EQUALS"
                                                                	ComparatorLessThanEquals    Comparator = "LESS_THAN_EQUALS"
                                                                )

                                                                  Enum values for Comparator

                                                                  func (Comparator) Values

                                                                  func (Comparator) Values() []Comparator

                                                                    Values returns all known values for Comparator. 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 Compatibility

                                                                    type Compatibility string
                                                                    const (
                                                                    	CompatibilityNone        Compatibility = "NONE"
                                                                    	CompatibilityDisabled    Compatibility = "DISABLED"
                                                                    	CompatibilityBackward    Compatibility = "BACKWARD"
                                                                    	CompatibilityBackwardAll Compatibility = "BACKWARD_ALL"
                                                                    	CompatibilityForward     Compatibility = "FORWARD"
                                                                    	CompatibilityForwardAll  Compatibility = "FORWARD_ALL"
                                                                    	CompatibilityFull        Compatibility = "FULL"
                                                                    	CompatibilityFullAll     Compatibility = "FULL_ALL"
                                                                    )

                                                                      Enum values for Compatibility

                                                                      func (Compatibility) Values

                                                                      func (Compatibility) Values() []Compatibility

                                                                        Values returns all known values for Compatibility. 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 ConcurrentModificationException

                                                                        type ConcurrentModificationException struct {
                                                                        	Message *string
                                                                        }

                                                                          Two processes are trying to modify a resource simultaneously.

                                                                          func (*ConcurrentModificationException) Error

                                                                          func (*ConcurrentModificationException) ErrorCode

                                                                          func (e *ConcurrentModificationException) ErrorCode() string

                                                                          func (*ConcurrentModificationException) ErrorFault

                                                                          func (*ConcurrentModificationException) ErrorMessage

                                                                          func (e *ConcurrentModificationException) ErrorMessage() string

                                                                          type ConcurrentRunsExceededException

                                                                          type ConcurrentRunsExceededException struct {
                                                                          	Message *string
                                                                          }

                                                                            Too many jobs are being run concurrently.

                                                                            func (*ConcurrentRunsExceededException) Error

                                                                            func (*ConcurrentRunsExceededException) ErrorCode

                                                                            func (e *ConcurrentRunsExceededException) ErrorCode() string

                                                                            func (*ConcurrentRunsExceededException) ErrorFault

                                                                            func (*ConcurrentRunsExceededException) ErrorMessage

                                                                            func (e *ConcurrentRunsExceededException) ErrorMessage() string

                                                                            type Condition

                                                                            type Condition struct {
                                                                            
                                                                            	// The state of the crawler to which this condition applies.
                                                                            	CrawlState CrawlState
                                                                            
                                                                            	// The name of the crawler to which this condition applies.
                                                                            	CrawlerName *string
                                                                            
                                                                            	// The name of the job whose JobRuns this condition applies to, and on which this
                                                                            	// trigger waits.
                                                                            	JobName *string
                                                                            
                                                                            	// A logical operator.
                                                                            	LogicalOperator LogicalOperator
                                                                            
                                                                            	// The condition state. Currently, the only job states that a trigger can listen
                                                                            	// for are SUCCEEDED, STOPPED, FAILED, and TIMEOUT. The only crawler states that a
                                                                            	// trigger can listen for are SUCCEEDED, FAILED, and CANCELLED.
                                                                            	State JobRunState
                                                                            }

                                                                              Defines a condition under which a trigger fires.

                                                                              type ConditionCheckFailureException

                                                                              type ConditionCheckFailureException struct {
                                                                              	Message *string
                                                                              }

                                                                                A specified condition was not satisfied.

                                                                                func (*ConditionCheckFailureException) Error

                                                                                func (*ConditionCheckFailureException) ErrorCode

                                                                                func (e *ConditionCheckFailureException) ErrorCode() string

                                                                                func (*ConditionCheckFailureException) ErrorFault

                                                                                func (*ConditionCheckFailureException) ErrorMessage

                                                                                func (e *ConditionCheckFailureException) ErrorMessage() string

                                                                                type ConflictException

                                                                                type ConflictException struct {
                                                                                	Message *string
                                                                                }

                                                                                  The CreatePartitions API was called on a table that has indexes enabled.

                                                                                  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 ConfusionMatrix

                                                                                  type ConfusionMatrix struct {
                                                                                  
                                                                                  	// The number of matches in the data that the transform didn't find, in the
                                                                                  	// confusion matrix for your transform.
                                                                                  	NumFalseNegatives *int64
                                                                                  
                                                                                  	// The number of nonmatches in the data that the transform incorrectly classified
                                                                                  	// as a match, in the confusion matrix for your transform.
                                                                                  	NumFalsePositives *int64
                                                                                  
                                                                                  	// The number of nonmatches in the data that the transform correctly rejected, in
                                                                                  	// the confusion matrix for your transform.
                                                                                  	NumTrueNegatives *int64
                                                                                  
                                                                                  	// The number of matches in the data that the transform correctly found, in the
                                                                                  	// confusion matrix for your transform.
                                                                                  	NumTruePositives *int64
                                                                                  }

                                                                                    The confusion matrix shows you what your transform is predicting accurately and what types of errors it is making. For more information, see Confusion matrix (https://en.wikipedia.org/wiki/Confusion_matrix) in Wikipedia.

                                                                                    type Connection

                                                                                    type Connection struct {
                                                                                    
                                                                                    	// These key-value pairs define parameters for the connection:
                                                                                    	//
                                                                                    	// * HOST - The host
                                                                                    	// URI: either the fully qualified domain name (FQDN) or the IPv4 address of the
                                                                                    	// database host.
                                                                                    	//
                                                                                    	// * PORT - The port number, between 1024 and 65535, of the port on
                                                                                    	// which the database host is listening for database connections.
                                                                                    	//
                                                                                    	// * USER_NAME -
                                                                                    	// The name under which to log in to the database. The value string for USER_NAME
                                                                                    	// is "USERNAME".
                                                                                    	//
                                                                                    	// * PASSWORD - A password, if one is used, for the user name.
                                                                                    	//
                                                                                    	// *
                                                                                    	// ENCRYPTED_PASSWORD - When you enable connection password protection by setting
                                                                                    	// ConnectionPasswordEncryption in the Data Catalog encryption settings, this field
                                                                                    	// stores the encrypted password.
                                                                                    	//
                                                                                    	// * JDBC_DRIVER_JAR_URI - The Amazon Simple
                                                                                    	// Storage Service (Amazon S3) path of the JAR file that contains the JDBC driver
                                                                                    	// to use.
                                                                                    	//
                                                                                    	// * JDBC_DRIVER_CLASS_NAME - The class name of the JDBC driver to use.
                                                                                    	//
                                                                                    	// *
                                                                                    	// JDBC_ENGINE - The name of the JDBC engine to use.
                                                                                    	//
                                                                                    	// * JDBC_ENGINE_VERSION - The
                                                                                    	// version of the JDBC engine to use.
                                                                                    	//
                                                                                    	// * CONFIG_FILES - (Reserved for future
                                                                                    	// use.)
                                                                                    	//
                                                                                    	// * INSTANCE_ID - The instance ID to use.
                                                                                    	//
                                                                                    	// * JDBC_CONNECTION_URL - The URL
                                                                                    	// for connecting to a JDBC data source.
                                                                                    	//
                                                                                    	// * JDBC_ENFORCE_SSL - A Boolean string
                                                                                    	// (true, false) specifying whether Secure Sockets Layer (SSL) with hostname
                                                                                    	// matching is enforced for the JDBC connection on the client. The default is
                                                                                    	// false.
                                                                                    	//
                                                                                    	// * CUSTOM_JDBC_CERT - An Amazon S3 location specifying the customer's
                                                                                    	// root certificate. AWS Glue uses this root certificate to validate the customer’s
                                                                                    	// certificate when connecting to the customer database. AWS Glue only handles
                                                                                    	// X.509 certificates. The certificate provided must be DER-encoded and supplied in
                                                                                    	// Base64 encoding PEM format.
                                                                                    	//
                                                                                    	// * SKIP_CUSTOM_JDBC_CERT_VALIDATION - By default,
                                                                                    	// this is false. AWS Glue validates the Signature algorithm and Subject Public Key
                                                                                    	// Algorithm for the customer certificate. The only permitted algorithms for the
                                                                                    	// Signature algorithm are SHA256withRSA, SHA384withRSA or SHA512withRSA. For the
                                                                                    	// Subject Public Key Algorithm, the key length must be at least 2048. You can set
                                                                                    	// the value of this property to true to skip AWS Glue’s validation of the customer
                                                                                    	// certificate.
                                                                                    	//
                                                                                    	// * CUSTOM_JDBC_CERT_STRING - A custom JDBC certificate string which
                                                                                    	// is used for domain match or distinguished name match to prevent a
                                                                                    	// man-in-the-middle attack. In Oracle database, this is used as the
                                                                                    	// SSL_SERVER_CERT_DN; in Microsoft SQL Server, this is used as the
                                                                                    	// hostNameInCertificate.
                                                                                    	//
                                                                                    	// * CONNECTION_URL - The URL for connecting to a general
                                                                                    	// (non-JDBC) data source.
                                                                                    	//
                                                                                    	// * KAFKA_BOOTSTRAP_SERVERS - A comma-separated list of
                                                                                    	// host and port pairs that are the addresses of the Apache Kafka brokers in a
                                                                                    	// Kafka cluster to which a Kafka client will connect to and bootstrap itself.
                                                                                    	//
                                                                                    	// *
                                                                                    	// KAFKA_SSL_ENABLED - Whether to enable or disable SSL on an Apache Kafka
                                                                                    	// connection. Default value is "true".
                                                                                    	//
                                                                                    	// * KAFKA_CUSTOM_CERT - The Amazon S3 URL
                                                                                    	// for the private CA cert file (.pem format). The default is an empty string.
                                                                                    	//
                                                                                    	// *
                                                                                    	// KAFKA_SKIP_CUSTOM_CERT_VALIDATION - Whether to skip the validation of the CA
                                                                                    	// cert file or not. AWS Glue validates for three algorithms: SHA256withRSA,
                                                                                    	// SHA384withRSA and SHA512withRSA. Default value is "false".
                                                                                    	ConnectionProperties map[string]string
                                                                                    
                                                                                    	// The type of the connection. Currently, SFTP is not supported.
                                                                                    	ConnectionType ConnectionType
                                                                                    
                                                                                    	// The time that this connection definition was created.
                                                                                    	CreationTime *time.Time
                                                                                    
                                                                                    	// The description of the connection.
                                                                                    	Description *string
                                                                                    
                                                                                    	// The user, group, or role that last updated this connection definition.
                                                                                    	LastUpdatedBy *string
                                                                                    
                                                                                    	// The last time that this connection definition was updated.
                                                                                    	LastUpdatedTime *time.Time
                                                                                    
                                                                                    	// A list of criteria that can be used in selecting this connection.
                                                                                    	MatchCriteria []string
                                                                                    
                                                                                    	// The name of the connection definition.
                                                                                    	Name *string
                                                                                    
                                                                                    	// A map of physical connection requirements, such as virtual private cloud (VPC)
                                                                                    	// and SecurityGroup, that are needed to make this connection successfully.
                                                                                    	PhysicalConnectionRequirements *PhysicalConnectionRequirements
                                                                                    }

                                                                                      Defines a connection to a data source.

                                                                                      type ConnectionInput

                                                                                      type ConnectionInput struct {
                                                                                      
                                                                                      	// These key-value pairs define parameters for the connection.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	ConnectionProperties map[string]string
                                                                                      
                                                                                      	// The type of the connection. Currently, these types are supported:
                                                                                      	//
                                                                                      	// * JDBC -
                                                                                      	// Designates a connection to a database through Java Database Connectivity
                                                                                      	// (JDBC).
                                                                                      	//
                                                                                      	// * KAFKA - Designates a connection to an Apache Kafka streaming
                                                                                      	// platform.
                                                                                      	//
                                                                                      	// * MONGODB - Designates a connection to a MongoDB document
                                                                                      	// database.
                                                                                      	//
                                                                                      	// * NETWORK - Designates a network connection to a data source within
                                                                                      	// an Amazon Virtual Private Cloud environment (Amazon VPC).
                                                                                      	//
                                                                                      	// SFTP is not
                                                                                      	// supported.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	ConnectionType ConnectionType
                                                                                      
                                                                                      	// The name of the connection.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	Name *string
                                                                                      
                                                                                      	// The description of the connection.
                                                                                      	Description *string
                                                                                      
                                                                                      	// A list of criteria that can be used in selecting this connection.
                                                                                      	MatchCriteria []string
                                                                                      
                                                                                      	// A map of physical connection requirements, such as virtual private cloud (VPC)
                                                                                      	// and SecurityGroup, that are needed to successfully make this connection.
                                                                                      	PhysicalConnectionRequirements *PhysicalConnectionRequirements
                                                                                      }

                                                                                        A structure that is used to specify a connection to create or update.

                                                                                        type ConnectionPasswordEncryption

                                                                                        type ConnectionPasswordEncryption struct {
                                                                                        
                                                                                        	// When the ReturnConnectionPasswordEncrypted flag is set to "true", passwords
                                                                                        	// remain encrypted in the responses of GetConnection and GetConnections. This
                                                                                        	// encryption takes effect independently from catalog encryption.
                                                                                        	//
                                                                                        	// This member is required.
                                                                                        	ReturnConnectionPasswordEncrypted bool
                                                                                        
                                                                                        	// An AWS KMS key that is used to encrypt the connection password. If connection
                                                                                        	// password protection is enabled, the caller of CreateConnection and
                                                                                        	// UpdateConnection needs at least kms:Encrypt permission on the specified AWS KMS
                                                                                        	// key, to encrypt passwords before storing them in the Data Catalog. You can set
                                                                                        	// the decrypt permission to enable or restrict access on the password key
                                                                                        	// according to your security requirements.
                                                                                        	AwsKmsKeyId *string
                                                                                        }

                                                                                          The data structure used by the Data Catalog to encrypt the password as part of CreateConnection or UpdateConnection and store it in the ENCRYPTED_PASSWORD field in the connection properties. You can enable catalog encryption or only password encryption. When a CreationConnection request arrives containing a password, the Data Catalog first encrypts the password using your AWS KMS key. It then encrypts the whole connection object again if catalog encryption is also enabled. This encryption requires that you set AWS KMS key permissions to enable or restrict access on the password key according to your security requirements. For example, you might want only administrators to have decrypt permission on the password key.

                                                                                          type ConnectionPropertyKey

                                                                                          type ConnectionPropertyKey string
                                                                                          const (
                                                                                          	ConnectionPropertyKeyHost                          ConnectionPropertyKey = "HOST"
                                                                                          	ConnectionPropertyKeyPort                          ConnectionPropertyKey = "PORT"
                                                                                          	ConnectionPropertyKeyUserName                      ConnectionPropertyKey = "USERNAME"
                                                                                          	ConnectionPropertyKeyPassword                      ConnectionPropertyKey = "PASSWORD"
                                                                                          	ConnectionPropertyKeyEncryptedPassword             ConnectionPropertyKey = "ENCRYPTED_PASSWORD"
                                                                                          	ConnectionPropertyKeyJdbcDriverJarUri              ConnectionPropertyKey = "JDBC_DRIVER_JAR_URI"
                                                                                          	ConnectionPropertyKeyJdbcDriverClassName           ConnectionPropertyKey = "JDBC_DRIVER_CLASS_NAME"
                                                                                          	ConnectionPropertyKeyJdbcEngine                    ConnectionPropertyKey = "JDBC_ENGINE"
                                                                                          	ConnectionPropertyKeyJdbcEngineVersion             ConnectionPropertyKey = "JDBC_ENGINE_VERSION"
                                                                                          	ConnectionPropertyKeyConfigFiles                   ConnectionPropertyKey = "CONFIG_FILES"
                                                                                          	ConnectionPropertyKeyInstanceId                    ConnectionPropertyKey = "INSTANCE_ID"
                                                                                          	ConnectionPropertyKeyJdbcConnectionUrl             ConnectionPropertyKey = "JDBC_CONNECTION_URL"
                                                                                          	ConnectionPropertyKeyJdbcEnforceSsl                ConnectionPropertyKey = "JDBC_ENFORCE_SSL"
                                                                                          	ConnectionPropertyKeyCustomJdbcCert                ConnectionPropertyKey = "CUSTOM_JDBC_CERT"
                                                                                          	ConnectionPropertyKeySkipCustomJdbcCertValidation  ConnectionPropertyKey = "SKIP_CUSTOM_JDBC_CERT_VALIDATION"
                                                                                          	ConnectionPropertyKeyCustomJdbcCertString          ConnectionPropertyKey = "CUSTOM_JDBC_CERT_STRING"
                                                                                          	ConnectionPropertyKeyConnectionUrl                 ConnectionPropertyKey = "CONNECTION_URL"
                                                                                          	ConnectionPropertyKeyKafkaBootstrapServers         ConnectionPropertyKey = "KAFKA_BOOTSTRAP_SERVERS"
                                                                                          	ConnectionPropertyKeyKafkaSslEnabled               ConnectionPropertyKey = "KAFKA_SSL_ENABLED"
                                                                                          	ConnectionPropertyKeyKafkaCustomCert               ConnectionPropertyKey = "KAFKA_CUSTOM_CERT"
                                                                                          	ConnectionPropertyKeyKafkaSkipCustomCertValidation ConnectionPropertyKey = "KAFKA_SKIP_CUSTOM_CERT_VALIDATION"
                                                                                          )

                                                                                            Enum values for ConnectionPropertyKey

                                                                                            func (ConnectionPropertyKey) Values

                                                                                              Values returns all known values for ConnectionPropertyKey. 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 ConnectionType

                                                                                              type ConnectionType string
                                                                                              const (
                                                                                              	ConnectionTypeJdbc    ConnectionType = "JDBC"
                                                                                              	ConnectionTypeSftp    ConnectionType = "SFTP"
                                                                                              	ConnectionTypeMongodb ConnectionType = "MONGODB"
                                                                                              	ConnectionTypeKafka   ConnectionType = "KAFKA"
                                                                                              	ConnectionTypeNetwork ConnectionType = "NETWORK"
                                                                                              )

                                                                                                Enum values for ConnectionType

                                                                                                func (ConnectionType) Values

                                                                                                func (ConnectionType) Values() []ConnectionType

                                                                                                  Values returns all known values for ConnectionType. 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 ConnectionsList

                                                                                                  type ConnectionsList struct {
                                                                                                  
                                                                                                  	// A list of connections used by the job.
                                                                                                  	Connections []string
                                                                                                  }

                                                                                                    Specifies the connections used by a job.

                                                                                                    type Crawl

                                                                                                    type Crawl struct {
                                                                                                    
                                                                                                    	// The date and time on which the crawl completed.
                                                                                                    	CompletedOn *time.Time
                                                                                                    
                                                                                                    	// The error message associated with the crawl.
                                                                                                    	ErrorMessage *string
                                                                                                    
                                                                                                    	// The log group associated with the crawl.
                                                                                                    	LogGroup *string
                                                                                                    
                                                                                                    	// The log stream associated with the crawl.
                                                                                                    	LogStream *string
                                                                                                    
                                                                                                    	// The date and time on which the crawl started.
                                                                                                    	StartedOn *time.Time
                                                                                                    
                                                                                                    	// The state of the crawler.
                                                                                                    	State CrawlState
                                                                                                    }

                                                                                                      The details of a crawl in the workflow.

                                                                                                      type CrawlState

                                                                                                      type CrawlState string
                                                                                                      const (
                                                                                                      	CrawlStateRunning    CrawlState = "RUNNING"
                                                                                                      	CrawlStateCancelling CrawlState = "CANCELLING"
                                                                                                      	CrawlStateCancelled  CrawlState = "CANCELLED"
                                                                                                      	CrawlStateSucceeded  CrawlState = "SUCCEEDED"
                                                                                                      	CrawlStateFailed     CrawlState = "FAILED"
                                                                                                      )

                                                                                                        Enum values for CrawlState

                                                                                                        func (CrawlState) Values

                                                                                                        func (CrawlState) Values() []CrawlState

                                                                                                          Values returns all known values for CrawlState. 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 Crawler

                                                                                                          type Crawler struct {
                                                                                                          
                                                                                                          	// A list of UTF-8 strings that specify the custom classifiers that are associated
                                                                                                          	// with the crawler.
                                                                                                          	Classifiers []string
                                                                                                          
                                                                                                          	// Crawler configuration information. This versioned JSON string allows users to
                                                                                                          	// specify aspects of a crawler's behavior. For more information, see Configuring a
                                                                                                          	// Crawler (https://docs.aws.amazon.com/glue/latest/dg/crawler-configuration.html).
                                                                                                          	Configuration *string
                                                                                                          
                                                                                                          	// If the crawler is running, contains the total time elapsed since the last crawl
                                                                                                          	// began.
                                                                                                          	CrawlElapsedTime int64
                                                                                                          
                                                                                                          	// The name of the SecurityConfiguration structure to be used by this crawler.
                                                                                                          	CrawlerSecurityConfiguration *string
                                                                                                          
                                                                                                          	// The time that the crawler was created.
                                                                                                          	CreationTime *time.Time
                                                                                                          
                                                                                                          	// The name of the database in which the crawler's output is stored.
                                                                                                          	DatabaseName *string
                                                                                                          
                                                                                                          	// A description of the crawler.
                                                                                                          	Description *string
                                                                                                          
                                                                                                          	// The status of the last crawl, and potentially error information if an error
                                                                                                          	// occurred.
                                                                                                          	LastCrawl *LastCrawlInfo
                                                                                                          
                                                                                                          	// The time that the crawler was last updated.
                                                                                                          	LastUpdated *time.Time
                                                                                                          
                                                                                                          	// A configuration that specifies whether data lineage is enabled for the crawler.
                                                                                                          	LineageConfiguration *LineageConfiguration
                                                                                                          
                                                                                                          	// The name of the crawler.
                                                                                                          	Name *string
                                                                                                          
                                                                                                          	// A policy that specifies whether to crawl the entire dataset again, or to crawl
                                                                                                          	// only folders that were added since the last crawler run.
                                                                                                          	RecrawlPolicy *RecrawlPolicy
                                                                                                          
                                                                                                          	// The Amazon Resource Name (ARN) of an IAM role that's used to access customer
                                                                                                          	// resources, such as Amazon Simple Storage Service (Amazon S3) data.
                                                                                                          	Role *string
                                                                                                          
                                                                                                          	// For scheduled crawlers, the schedule when the crawler runs.
                                                                                                          	Schedule *Schedule
                                                                                                          
                                                                                                          	// The policy that specifies update and delete behaviors for the crawler.
                                                                                                          	SchemaChangePolicy *SchemaChangePolicy
                                                                                                          
                                                                                                          	// Indicates whether the crawler is running, or whether a run is pending.
                                                                                                          	State CrawlerState
                                                                                                          
                                                                                                          	// The prefix added to the names of tables that are created.
                                                                                                          	TablePrefix *string
                                                                                                          
                                                                                                          	// A collection of targets to crawl.
                                                                                                          	Targets *CrawlerTargets
                                                                                                          
                                                                                                          	// The version of the crawler.
                                                                                                          	Version int64
                                                                                                          }

                                                                                                            Specifies a crawler program that examines a data source and uses classifiers to try to determine its schema. If successful, the crawler records metadata concerning the data source in the AWS Glue Data Catalog.

                                                                                                            type CrawlerLineageSettings

                                                                                                            type CrawlerLineageSettings string
                                                                                                            const (
                                                                                                            	CrawlerLineageSettingsEnable  CrawlerLineageSettings = "ENABLE"
                                                                                                            	CrawlerLineageSettingsDisable CrawlerLineageSettings = "DISABLE"
                                                                                                            )

                                                                                                              Enum values for CrawlerLineageSettings

                                                                                                              func (CrawlerLineageSettings) Values

                                                                                                                Values returns all known values for CrawlerLineageSettings. 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 CrawlerMetrics

                                                                                                                type CrawlerMetrics struct {
                                                                                                                
                                                                                                                	// The name of the crawler.
                                                                                                                	CrawlerName *string
                                                                                                                
                                                                                                                	// The duration of the crawler's most recent run, in seconds.
                                                                                                                	LastRuntimeSeconds float64
                                                                                                                
                                                                                                                	// The median duration of this crawler's runs, in seconds.
                                                                                                                	MedianRuntimeSeconds float64
                                                                                                                
                                                                                                                	// True if the crawler is still estimating how long it will take to complete this
                                                                                                                	// run.
                                                                                                                	StillEstimating bool
                                                                                                                
                                                                                                                	// The number of tables created by this crawler.
                                                                                                                	TablesCreated int32
                                                                                                                
                                                                                                                	// The number of tables deleted by this crawler.
                                                                                                                	TablesDeleted int32
                                                                                                                
                                                                                                                	// The number of tables updated by this crawler.
                                                                                                                	TablesUpdated int32
                                                                                                                
                                                                                                                	// The estimated time left to complete a running crawl.
                                                                                                                	TimeLeftSeconds float64
                                                                                                                }

                                                                                                                  Metrics for a specified crawler.

                                                                                                                  type CrawlerNodeDetails

                                                                                                                  type CrawlerNodeDetails struct {
                                                                                                                  
                                                                                                                  	// A list of crawls represented by the crawl node.
                                                                                                                  	Crawls []Crawl
                                                                                                                  }

                                                                                                                    The details of a Crawler node present in the workflow.

                                                                                                                    type CrawlerNotRunningException

                                                                                                                    type CrawlerNotRunningException struct {
                                                                                                                    	Message *string
                                                                                                                    }

                                                                                                                      The specified crawler is not running.

                                                                                                                      func (*CrawlerNotRunningException) Error

                                                                                                                      func (*CrawlerNotRunningException) ErrorCode

                                                                                                                      func (e *CrawlerNotRunningException) ErrorCode() string

                                                                                                                      func (*CrawlerNotRunningException) ErrorFault

                                                                                                                      func (*CrawlerNotRunningException) ErrorMessage

                                                                                                                      func (e *CrawlerNotRunningException) ErrorMessage() string

                                                                                                                      type CrawlerRunningException

                                                                                                                      type CrawlerRunningException struct {
                                                                                                                      	Message *string
                                                                                                                      }

                                                                                                                        The operation cannot be performed because the crawler is already running.

                                                                                                                        func (*CrawlerRunningException) Error

                                                                                                                        func (e *CrawlerRunningException) Error() string

                                                                                                                        func (*CrawlerRunningException) ErrorCode

                                                                                                                        func (e *CrawlerRunningException) ErrorCode() string

                                                                                                                        func (*CrawlerRunningException) ErrorFault

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

                                                                                                                        func (*CrawlerRunningException) ErrorMessage

                                                                                                                        func (e *CrawlerRunningException) ErrorMessage() string

                                                                                                                        type CrawlerState

                                                                                                                        type CrawlerState string
                                                                                                                        const (
                                                                                                                        	CrawlerStateReady    CrawlerState = "READY"
                                                                                                                        	CrawlerStateRunning  CrawlerState = "RUNNING"
                                                                                                                        	CrawlerStateStopping CrawlerState = "STOPPING"
                                                                                                                        )

                                                                                                                          Enum values for CrawlerState

                                                                                                                          func (CrawlerState) Values

                                                                                                                          func (CrawlerState) Values() []CrawlerState

                                                                                                                            Values returns all known values for CrawlerState. 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 CrawlerStoppingException

                                                                                                                            type CrawlerStoppingException struct {
                                                                                                                            	Message *string
                                                                                                                            }

                                                                                                                              The specified crawler is stopping.

                                                                                                                              func (*CrawlerStoppingException) Error

                                                                                                                              func (e *CrawlerStoppingException) Error() string

                                                                                                                              func (*CrawlerStoppingException) ErrorCode

                                                                                                                              func (e *CrawlerStoppingException) ErrorCode() string

                                                                                                                              func (*CrawlerStoppingException) ErrorFault

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

                                                                                                                              func (*CrawlerStoppingException) ErrorMessage

                                                                                                                              func (e *CrawlerStoppingException) ErrorMessage() string

                                                                                                                              type CrawlerTargets

                                                                                                                              type CrawlerTargets struct {
                                                                                                                              
                                                                                                                              	// Specifies AWS Glue Data Catalog targets.
                                                                                                                              	CatalogTargets []CatalogTarget
                                                                                                                              
                                                                                                                              	// Specifies Amazon DynamoDB targets.
                                                                                                                              	DynamoDBTargets []DynamoDBTarget
                                                                                                                              
                                                                                                                              	// Specifies JDBC targets.
                                                                                                                              	JdbcTargets []JdbcTarget
                                                                                                                              
                                                                                                                              	// Specifies Amazon DocumentDB or MongoDB targets.
                                                                                                                              	MongoDBTargets []MongoDBTarget
                                                                                                                              
                                                                                                                              	// Specifies Amazon Simple Storage Service (Amazon S3) targets.
                                                                                                                              	S3Targets []S3Target
                                                                                                                              }

                                                                                                                                Specifies data stores to crawl.

                                                                                                                                type CreateCsvClassifierRequest

                                                                                                                                type CreateCsvClassifierRequest struct {
                                                                                                                                
                                                                                                                                	// The name of the classifier.
                                                                                                                                	//
                                                                                                                                	// This member is required.
                                                                                                                                	Name *string
                                                                                                                                
                                                                                                                                	// Enables the processing of files that contain only one column.
                                                                                                                                	AllowSingleColumn *bool
                                                                                                                                
                                                                                                                                	// Indicates whether the CSV file contains a header.
                                                                                                                                	ContainsHeader CsvHeaderOption
                                                                                                                                
                                                                                                                                	// A custom symbol to denote what separates each column entry in the row.
                                                                                                                                	Delimiter *string
                                                                                                                                
                                                                                                                                	// Specifies not to trim values before identifying the type of column values. The
                                                                                                                                	// default value is true.
                                                                                                                                	DisableValueTrimming *bool
                                                                                                                                
                                                                                                                                	// A list of strings representing column names.
                                                                                                                                	Header []string
                                                                                                                                
                                                                                                                                	// A custom symbol to denote what combines content into a single column value. Must
                                                                                                                                	// be different from the column delimiter.
                                                                                                                                	QuoteSymbol *string
                                                                                                                                }

                                                                                                                                  Specifies a custom CSV classifier for CreateClassifier to create.

                                                                                                                                  type CreateGrokClassifierRequest

                                                                                                                                  type CreateGrokClassifierRequest struct {
                                                                                                                                  
                                                                                                                                  	// An identifier of the data format that the classifier matches, such as Twitter,
                                                                                                                                  	// JSON, Omniture logs, Amazon CloudWatch Logs, and so on.
                                                                                                                                  	//
                                                                                                                                  	// This member is required.
                                                                                                                                  	Classification *string
                                                                                                                                  
                                                                                                                                  	// The grok pattern used by this classifier.
                                                                                                                                  	//
                                                                                                                                  	// This member is required.
                                                                                                                                  	GrokPattern *string
                                                                                                                                  
                                                                                                                                  	// The name of the new classifier.
                                                                                                                                  	//
                                                                                                                                  	// This member is required.
                                                                                                                                  	Name *string
                                                                                                                                  
                                                                                                                                  	// Optional custom grok patterns used by this classifier.
                                                                                                                                  	CustomPatterns *string
                                                                                                                                  }

                                                                                                                                    Specifies a grok classifier for CreateClassifier to create.

                                                                                                                                    type CreateJsonClassifierRequest

                                                                                                                                    type CreateJsonClassifierRequest struct {
                                                                                                                                    
                                                                                                                                    	// A JsonPath string defining the JSON data for the classifier to classify. AWS
                                                                                                                                    	// Glue supports a subset of JsonPath, as described in Writing JsonPath Custom
                                                                                                                                    	// Classifiers
                                                                                                                                    	// (https://docs.aws.amazon.com/glue/latest/dg/custom-classifier.html#custom-classifier-json).
                                                                                                                                    	//
                                                                                                                                    	// This member is required.
                                                                                                                                    	JsonPath *string
                                                                                                                                    
                                                                                                                                    	// The name of the classifier.
                                                                                                                                    	//
                                                                                                                                    	// This member is required.
                                                                                                                                    	Name *string
                                                                                                                                    }

                                                                                                                                      Specifies a JSON classifier for CreateClassifier to create.

                                                                                                                                      type CreateXMLClassifierRequest

                                                                                                                                      type CreateXMLClassifierRequest struct {
                                                                                                                                      
                                                                                                                                      	// An identifier of the data format that the classifier matches.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	Classification *string
                                                                                                                                      
                                                                                                                                      	// The name of the classifier.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	Name *string
                                                                                                                                      
                                                                                                                                      	// The XML tag designating the element that contains each record in an XML document
                                                                                                                                      	// being parsed. This can't identify a self-closing element (closed by />). An
                                                                                                                                      	// empty row element that contains only attributes can be parsed as long as it ends
                                                                                                                                      	// with a closing tag (for example,  is okay, but  is not).
                                                                                                                                      	RowTag *string
                                                                                                                                      }

                                                                                                                                        Specifies an XML classifier for CreateClassifier to create.

                                                                                                                                        type CsvClassifier

                                                                                                                                        type CsvClassifier struct {
                                                                                                                                        
                                                                                                                                        	// The name of the classifier.
                                                                                                                                        	//
                                                                                                                                        	// This member is required.
                                                                                                                                        	Name *string
                                                                                                                                        
                                                                                                                                        	// Enables the processing of files that contain only one column.
                                                                                                                                        	AllowSingleColumn *bool
                                                                                                                                        
                                                                                                                                        	// Indicates whether the CSV file contains a header.
                                                                                                                                        	ContainsHeader CsvHeaderOption
                                                                                                                                        
                                                                                                                                        	// The time that this classifier was registered.
                                                                                                                                        	CreationTime *time.Time
                                                                                                                                        
                                                                                                                                        	// A custom symbol to denote what separates each column entry in the row.
                                                                                                                                        	Delimiter *string
                                                                                                                                        
                                                                                                                                        	// Specifies not to trim values before identifying the type of column values. The
                                                                                                                                        	// default value is true.
                                                                                                                                        	DisableValueTrimming *bool
                                                                                                                                        
                                                                                                                                        	// A list of strings representing column names.
                                                                                                                                        	Header []string
                                                                                                                                        
                                                                                                                                        	// The time that this classifier was last updated.
                                                                                                                                        	LastUpdated *time.Time
                                                                                                                                        
                                                                                                                                        	// A custom symbol to denote what combines content into a single column value. It
                                                                                                                                        	// must be different from the column delimiter.
                                                                                                                                        	QuoteSymbol *string
                                                                                                                                        
                                                                                                                                        	// The version of this classifier.
                                                                                                                                        	Version int64
                                                                                                                                        }

                                                                                                                                          A classifier for custom CSV content.

                                                                                                                                          type CsvHeaderOption

                                                                                                                                          type CsvHeaderOption string
                                                                                                                                          const (
                                                                                                                                          	CsvHeaderOptionUnknown CsvHeaderOption = "UNKNOWN"
                                                                                                                                          	CsvHeaderOptionPresent CsvHeaderOption = "PRESENT"
                                                                                                                                          	CsvHeaderOptionAbsent  CsvHeaderOption = "ABSENT"
                                                                                                                                          )

                                                                                                                                            Enum values for CsvHeaderOption

                                                                                                                                            func (CsvHeaderOption) Values

                                                                                                                                            func (CsvHeaderOption) Values() []CsvHeaderOption

                                                                                                                                              Values returns all known values for CsvHeaderOption. 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 DataCatalogEncryptionSettings

                                                                                                                                              type DataCatalogEncryptionSettings struct {
                                                                                                                                              
                                                                                                                                              	// When connection password protection is enabled, the Data Catalog uses a
                                                                                                                                              	// customer-provided key to encrypt the password as part of CreateConnection or
                                                                                                                                              	// UpdateConnection and store it in the ENCRYPTED_PASSWORD field in the connection
                                                                                                                                              	// properties. You can enable catalog encryption or only password encryption.
                                                                                                                                              	ConnectionPasswordEncryption *ConnectionPasswordEncryption
                                                                                                                                              
                                                                                                                                              	// Specifies the encryption-at-rest configuration for the Data Catalog.
                                                                                                                                              	EncryptionAtRest *EncryptionAtRest
                                                                                                                                              }

                                                                                                                                                Contains configuration information for maintaining Data Catalog security.

                                                                                                                                                type DataFormat

                                                                                                                                                type DataFormat string
                                                                                                                                                const (
                                                                                                                                                	DataFormatAvro DataFormat = "AVRO"
                                                                                                                                                )

                                                                                                                                                  Enum values for DataFormat

                                                                                                                                                  func (DataFormat) Values

                                                                                                                                                  func (DataFormat) Values() []DataFormat

                                                                                                                                                    Values returns all known values for DataFormat. 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 DataLakePrincipal

                                                                                                                                                    type DataLakePrincipal struct {
                                                                                                                                                    
                                                                                                                                                    	// An identifier for the AWS Lake Formation principal.
                                                                                                                                                    	DataLakePrincipalIdentifier *string
                                                                                                                                                    }

                                                                                                                                                      The AWS Lake Formation principal.

                                                                                                                                                      type Database

                                                                                                                                                      type Database struct {
                                                                                                                                                      
                                                                                                                                                      	// The name of the database. For Hive compatibility, this is folded to lowercase
                                                                                                                                                      	// when it is stored.
                                                                                                                                                      	//
                                                                                                                                                      	// This member is required.
                                                                                                                                                      	Name *string
                                                                                                                                                      
                                                                                                                                                      	// The ID of the Data Catalog in which the database resides.
                                                                                                                                                      	CatalogId *string
                                                                                                                                                      
                                                                                                                                                      	// Creates a set of default permissions on the table for principals.
                                                                                                                                                      	CreateTableDefaultPermissions []PrincipalPermissions
                                                                                                                                                      
                                                                                                                                                      	// The time at which the metadata database was created in the catalog.
                                                                                                                                                      	CreateTime *time.Time
                                                                                                                                                      
                                                                                                                                                      	// A description of the database.
                                                                                                                                                      	Description *string
                                                                                                                                                      
                                                                                                                                                      	// The location of the database (for example, an HDFS path).
                                                                                                                                                      	LocationUri *string
                                                                                                                                                      
                                                                                                                                                      	// These key-value pairs define parameters and properties of the database.
                                                                                                                                                      	Parameters map[string]string
                                                                                                                                                      
                                                                                                                                                      	// A DatabaseIdentifier structure that describes a target database for resource
                                                                                                                                                      	// linking.
                                                                                                                                                      	TargetDatabase *DatabaseIdentifier
                                                                                                                                                      }

                                                                                                                                                        The Database object represents a logical grouping of tables that might reside in a Hive metastore or an RDBMS.

                                                                                                                                                        type DatabaseIdentifier

                                                                                                                                                        type DatabaseIdentifier struct {
                                                                                                                                                        
                                                                                                                                                        	// The ID of the Data Catalog in which the database resides.
                                                                                                                                                        	CatalogId *string
                                                                                                                                                        
                                                                                                                                                        	// The name of the catalog database.
                                                                                                                                                        	DatabaseName *string
                                                                                                                                                        }

                                                                                                                                                          A structure that describes a target database for resource linking.

                                                                                                                                                          type DatabaseInput

                                                                                                                                                          type DatabaseInput struct {
                                                                                                                                                          
                                                                                                                                                          	// The name of the database. For Hive compatibility, this is folded to lowercase
                                                                                                                                                          	// when it is stored.
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	Name *string
                                                                                                                                                          
                                                                                                                                                          	// Creates a set of default permissions on the table for principals.
                                                                                                                                                          	CreateTableDefaultPermissions []PrincipalPermissions
                                                                                                                                                          
                                                                                                                                                          	// A description of the database.
                                                                                                                                                          	Description *string
                                                                                                                                                          
                                                                                                                                                          	// The location of the database (for example, an HDFS path).
                                                                                                                                                          	LocationUri *string
                                                                                                                                                          
                                                                                                                                                          	// These key-value pairs define parameters and properties of the database. These
                                                                                                                                                          	// key-value pairs define parameters and properties of the database.
                                                                                                                                                          	Parameters map[string]string
                                                                                                                                                          
                                                                                                                                                          	// A DatabaseIdentifier structure that describes a target database for resource
                                                                                                                                                          	// linking.
                                                                                                                                                          	TargetDatabase *DatabaseIdentifier
                                                                                                                                                          }

                                                                                                                                                            The structure used to create or update a database.

                                                                                                                                                            type DateColumnStatisticsData

                                                                                                                                                            type DateColumnStatisticsData struct {
                                                                                                                                                            
                                                                                                                                                            	// The number of distinct values in a column.
                                                                                                                                                            	//
                                                                                                                                                            	// This member is required.
                                                                                                                                                            	NumberOfDistinctValues int64
                                                                                                                                                            
                                                                                                                                                            	// The number of null values in the column.
                                                                                                                                                            	//
                                                                                                                                                            	// This member is required.
                                                                                                                                                            	NumberOfNulls int64
                                                                                                                                                            
                                                                                                                                                            	// The highest value in the column.
                                                                                                                                                            	MaximumValue *time.Time
                                                                                                                                                            
                                                                                                                                                            	// The lowest value in the column.
                                                                                                                                                            	MinimumValue *time.Time
                                                                                                                                                            }

                                                                                                                                                              Defines column statistics supported for timestamp data columns.

                                                                                                                                                              type DecimalColumnStatisticsData

                                                                                                                                                              type DecimalColumnStatisticsData struct {
                                                                                                                                                              
                                                                                                                                                              	// The number of distinct values in a column.
                                                                                                                                                              	//
                                                                                                                                                              	// This member is required.
                                                                                                                                                              	NumberOfDistinctValues int64
                                                                                                                                                              
                                                                                                                                                              	// The number of null values in the column.
                                                                                                                                                              	//
                                                                                                                                                              	// This member is required.
                                                                                                                                                              	NumberOfNulls int64
                                                                                                                                                              
                                                                                                                                                              	// The highest value in the column.
                                                                                                                                                              	MaximumValue *DecimalNumber
                                                                                                                                                              
                                                                                                                                                              	// The lowest value in the column.
                                                                                                                                                              	MinimumValue *DecimalNumber
                                                                                                                                                              }

                                                                                                                                                                Defines column statistics supported for fixed-point number data columns.

                                                                                                                                                                type DecimalNumber

                                                                                                                                                                type DecimalNumber struct {
                                                                                                                                                                
                                                                                                                                                                	// The scale that determines where the decimal point falls in the unscaled value.
                                                                                                                                                                	//
                                                                                                                                                                	// This member is required.
                                                                                                                                                                	Scale int32
                                                                                                                                                                
                                                                                                                                                                	// The unscaled numeric value.
                                                                                                                                                                	//
                                                                                                                                                                	// This member is required.
                                                                                                                                                                	UnscaledValue []byte
                                                                                                                                                                }

                                                                                                                                                                  Contains a numeric value in decimal format.

                                                                                                                                                                  type DeleteBehavior

                                                                                                                                                                  type DeleteBehavior string
                                                                                                                                                                  const (
                                                                                                                                                                  	DeleteBehaviorLog                 DeleteBehavior = "LOG"
                                                                                                                                                                  	DeleteBehaviorDeleteFromDatabase  DeleteBehavior = "DELETE_FROM_DATABASE"
                                                                                                                                                                  	DeleteBehaviorDeprecateInDatabase DeleteBehavior = "DEPRECATE_IN_DATABASE"
                                                                                                                                                                  )

                                                                                                                                                                    Enum values for DeleteBehavior

                                                                                                                                                                    func (DeleteBehavior) Values

                                                                                                                                                                    func (DeleteBehavior) Values() []DeleteBehavior

                                                                                                                                                                      Values returns all known values for DeleteBehavior. 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 DevEndpoint

                                                                                                                                                                      type DevEndpoint struct {
                                                                                                                                                                      
                                                                                                                                                                      	// A map of arguments used to configure the DevEndpoint. Valid arguments are:
                                                                                                                                                                      	//
                                                                                                                                                                      	// *
                                                                                                                                                                      	// "--enable-glue-datacatalog": ""
                                                                                                                                                                      	//
                                                                                                                                                                      	// * "GLUE_PYTHON_VERSION": "3"
                                                                                                                                                                      	//
                                                                                                                                                                      	// *
                                                                                                                                                                      	// "GLUE_PYTHON_VERSION": "2"
                                                                                                                                                                      	//
                                                                                                                                                                      	// You can specify a version of Python support for
                                                                                                                                                                      	// development endpoints by using the Arguments parameter in the CreateDevEndpoint
                                                                                                                                                                      	// or UpdateDevEndpoint APIs. If no arguments are provided, the version defaults to
                                                                                                                                                                      	// Python 2.
                                                                                                                                                                      	Arguments map[string]string
                                                                                                                                                                      
                                                                                                                                                                      	// The AWS Availability Zone where this DevEndpoint is located.
                                                                                                                                                                      	AvailabilityZone *string
                                                                                                                                                                      
                                                                                                                                                                      	// The point in time at which this DevEndpoint was created.
                                                                                                                                                                      	CreatedTimestamp *time.Time
                                                                                                                                                                      
                                                                                                                                                                      	// The name of the DevEndpoint.
                                                                                                                                                                      	EndpointName *string
                                                                                                                                                                      
                                                                                                                                                                      	// The path to one or more Java .jar files in an S3 bucket that should be loaded in
                                                                                                                                                                      	// your DevEndpoint. You can only use pure Java/Scala libraries with a DevEndpoint.
                                                                                                                                                                      	ExtraJarsS3Path *string
                                                                                                                                                                      
                                                                                                                                                                      	// The paths to one or more Python libraries in an Amazon S3 bucket that should be
                                                                                                                                                                      	// loaded in your DevEndpoint. Multiple values must be complete paths separated by
                                                                                                                                                                      	// a comma. You can only use pure Python libraries with a DevEndpoint. Libraries
                                                                                                                                                                      	// that rely on C extensions, such as the pandas (http://pandas.pydata.org/) Python
                                                                                                                                                                      	// data analysis library, are not currently supported.
                                                                                                                                                                      	ExtraPythonLibsS3Path *string
                                                                                                                                                                      
                                                                                                                                                                      	// The reason for a current failure in this DevEndpoint.
                                                                                                                                                                      	FailureReason *string
                                                                                                                                                                      
                                                                                                                                                                      	// Glue version determines the versions of Apache Spark and Python that AWS Glue
                                                                                                                                                                      	// supports. The Python version indicates the version supported for running your
                                                                                                                                                                      	// ETL scripts on development endpoints. For more information about the available
                                                                                                                                                                      	// AWS Glue versions and corresponding Spark and Python versions, see Glue version
                                                                                                                                                                      	// (https://docs.aws.amazon.com/glue/latest/dg/add-job.html) in the developer
                                                                                                                                                                      	// guide. Development endpoints that are created without specifying a Glue version
                                                                                                                                                                      	// default to Glue 0.9. You can specify a version of Python support for development
                                                                                                                                                                      	// endpoints by using the Arguments parameter in the CreateDevEndpoint or
                                                                                                                                                                      	// UpdateDevEndpoint APIs. If no arguments are provided, the version defaults to
                                                                                                                                                                      	// Python 2.
                                                                                                                                                                      	GlueVersion *string
                                                                                                                                                                      
                                                                                                                                                                      	// The point in time at which this DevEndpoint was last modified.
                                                                                                                                                                      	LastModifiedTimestamp *time.Time
                                                                                                                                                                      
                                                                                                                                                                      	// The status of the last update.
                                                                                                                                                                      	LastUpdateStatus *string
                                                                                                                                                                      
                                                                                                                                                                      	// The number of AWS Glue Data Processing Units (DPUs) allocated to this
                                                                                                                                                                      	// DevEndpoint.
                                                                                                                                                                      	NumberOfNodes int32
                                                                                                                                                                      
                                                                                                                                                                      	// The number of workers of a defined workerType that are allocated to the
                                                                                                                                                                      	// development endpoint. The maximum number of workers you can define are 299 for
                                                                                                                                                                      	// G.1X, and 149 for G.2X.
                                                                                                                                                                      	NumberOfWorkers *int32
                                                                                                                                                                      
                                                                                                                                                                      	// A private IP address to access the DevEndpoint within a VPC if the DevEndpoint
                                                                                                                                                                      	// is created within one. The PrivateAddress field is present only when you create
                                                                                                                                                                      	// the DevEndpoint within your VPC.
                                                                                                                                                                      	PrivateAddress *string
                                                                                                                                                                      
                                                                                                                                                                      	// The public IP address used by this DevEndpoint. The PublicAddress field is
                                                                                                                                                                      	// present only when you create a non-virtual private cloud (VPC) DevEndpoint.
                                                                                                                                                                      	PublicAddress *string
                                                                                                                                                                      
                                                                                                                                                                      	// The public key to be used by this DevEndpoint for authentication. This attribute
                                                                                                                                                                      	// is provided for backward compatibility because the recommended attribute to use
                                                                                                                                                                      	// is public keys.
                                                                                                                                                                      	PublicKey *string
                                                                                                                                                                      
                                                                                                                                                                      	// A list of public keys to be used by the DevEndpoints for authentication. Using
                                                                                                                                                                      	// this attribute is preferred over a single public key because the public keys
                                                                                                                                                                      	// allow you to have a different private key per client. If you previously created
                                                                                                                                                                      	// an endpoint with a public key, you must remove that key to be able to set a list
                                                                                                                                                                      	// of public keys. Call the UpdateDevEndpoint API operation with the public key
                                                                                                                                                                      	// content in the deletePublicKeys attribute, and the list of new keys in the
                                                                                                                                                                      	// addPublicKeys attribute.
                                                                                                                                                                      	PublicKeys []string
                                                                                                                                                                      
                                                                                                                                                                      	// The Amazon Resource Name (ARN) of the IAM role used in this DevEndpoint.
                                                                                                                                                                      	RoleArn *string
                                                                                                                                                                      
                                                                                                                                                                      	// The name of the SecurityConfiguration structure to be used with this
                                                                                                                                                                      	// DevEndpoint.
                                                                                                                                                                      	SecurityConfiguration *string
                                                                                                                                                                      
                                                                                                                                                                      	// A list of security group identifiers used in this DevEndpoint.
                                                                                                                                                                      	SecurityGroupIds []string
                                                                                                                                                                      
                                                                                                                                                                      	// The current status of this DevEndpoint.
                                                                                                                                                                      	Status *string
                                                                                                                                                                      
                                                                                                                                                                      	// The subnet ID for this DevEndpoint.
                                                                                                                                                                      	SubnetId *string
                                                                                                                                                                      
                                                                                                                                                                      	// The ID of the virtual private cloud (VPC) used by this DevEndpoint.
                                                                                                                                                                      	VpcId *string
                                                                                                                                                                      
                                                                                                                                                                      	// The type of predefined worker that is allocated to the development endpoint.
                                                                                                                                                                      	// Accepts a value of Standard, G.1X, or G.2X.
                                                                                                                                                                      	//
                                                                                                                                                                      	// * For the Standard worker type,
                                                                                                                                                                      	// each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors
                                                                                                                                                                      	// per worker.
                                                                                                                                                                      	//
                                                                                                                                                                      	// * For the G.1X worker type, each worker maps to 1 DPU (4 vCPU, 16
                                                                                                                                                                      	// GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this
                                                                                                                                                                      	// worker type for memory-intensive jobs.
                                                                                                                                                                      	//
                                                                                                                                                                      	// * For the G.2X worker type, each worker
                                                                                                                                                                      	// maps to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor
                                                                                                                                                                      	// per worker. We recommend this worker type for memory-intensive jobs.
                                                                                                                                                                      	//
                                                                                                                                                                      	// Known
                                                                                                                                                                      	// issue: when a development endpoint is created with the G.2XWorkerType
                                                                                                                                                                      	// configuration, the Spark drivers for the development endpoint will run on 4
                                                                                                                                                                      	// vCPU, 16 GB of memory, and a 64 GB disk.
                                                                                                                                                                      	WorkerType WorkerType
                                                                                                                                                                      
                                                                                                                                                                      	// The YARN endpoint address used by this DevEndpoint.
                                                                                                                                                                      	YarnEndpointAddress *string
                                                                                                                                                                      
                                                                                                                                                                      	// The Apache Zeppelin port for the remote Apache Spark interpreter.
                                                                                                                                                                      	ZeppelinRemoteSparkInterpreterPort int32
                                                                                                                                                                      }

                                                                                                                                                                        A development endpoint where a developer can remotely debug extract, transform, and load (ETL) scripts.

                                                                                                                                                                        type DevEndpointCustomLibraries

                                                                                                                                                                        type DevEndpointCustomLibraries struct {
                                                                                                                                                                        
                                                                                                                                                                        	// The path to one or more Java .jar files in an S3 bucket that should be loaded in
                                                                                                                                                                        	// your DevEndpoint. You can only use pure Java/Scala libraries with a DevEndpoint.
                                                                                                                                                                        	ExtraJarsS3Path *string
                                                                                                                                                                        
                                                                                                                                                                        	// The paths to one or more Python libraries in an Amazon Simple Storage Service
                                                                                                                                                                        	// (Amazon S3) bucket that should be loaded in your DevEndpoint. Multiple values
                                                                                                                                                                        	// must be complete paths separated by a comma. You can only use pure Python
                                                                                                                                                                        	// libraries with a DevEndpoint. Libraries that rely on C extensions, such as the
                                                                                                                                                                        	// pandas (http://pandas.pydata.org/) Python data analysis library, are not
                                                                                                                                                                        	// currently supported.
                                                                                                                                                                        	ExtraPythonLibsS3Path *string
                                                                                                                                                                        }

                                                                                                                                                                          Custom libraries to be loaded into a development endpoint.

                                                                                                                                                                          type DoubleColumnStatisticsData

                                                                                                                                                                          type DoubleColumnStatisticsData struct {
                                                                                                                                                                          
                                                                                                                                                                          	// The number of distinct values in a column.
                                                                                                                                                                          	//
                                                                                                                                                                          	// This member is required.
                                                                                                                                                                          	NumberOfDistinctValues int64
                                                                                                                                                                          
                                                                                                                                                                          	// The number of null values in the column.
                                                                                                                                                                          	//
                                                                                                                                                                          	// This member is required.
                                                                                                                                                                          	NumberOfNulls int64
                                                                                                                                                                          
                                                                                                                                                                          	// The highest value in the column.
                                                                                                                                                                          	MaximumValue float64
                                                                                                                                                                          
                                                                                                                                                                          	// The lowest value in the column.
                                                                                                                                                                          	MinimumValue float64
                                                                                                                                                                          }

                                                                                                                                                                            Defines column statistics supported for floating-point number data columns.

                                                                                                                                                                            type DynamoDBTarget

                                                                                                                                                                            type DynamoDBTarget struct {
                                                                                                                                                                            
                                                                                                                                                                            	// The name of the DynamoDB table to crawl.
                                                                                                                                                                            	Path *string
                                                                                                                                                                            
                                                                                                                                                                            	// Indicates whether to scan all the records, or to sample rows from the table.
                                                                                                                                                                            	// Scanning all the records can take a long time when the table is not a high
                                                                                                                                                                            	// throughput table. A value of true means to scan all records, while a value of
                                                                                                                                                                            	// false means to sample the records. If no value is specified, the value defaults
                                                                                                                                                                            	// to true.
                                                                                                                                                                            	ScanAll *bool
                                                                                                                                                                            
                                                                                                                                                                            	// The percentage of the configured read capacity units to use by the AWS Glue
                                                                                                                                                                            	// crawler. Read capacity units is a term defined by DynamoDB, and is a numeric
                                                                                                                                                                            	// value that acts as rate limiter for the number of reads that can be performed on
                                                                                                                                                                            	// that table per second. The valid values are null or a value between 0.1 to 1.5.
                                                                                                                                                                            	// A null value is used when user does not provide a value, and defaults to 0.5 of
                                                                                                                                                                            	// the configured Read Capacity Unit (for provisioned tables), or 0.25 of the max
                                                                                                                                                                            	// configured Read Capacity Unit (for tables using on-demand mode).
                                                                                                                                                                            	ScanRate *float64
                                                                                                                                                                            }

                                                                                                                                                                              Specifies an Amazon DynamoDB table to crawl.

                                                                                                                                                                              type Edge

                                                                                                                                                                              type Edge struct {
                                                                                                                                                                              
                                                                                                                                                                              	// The unique of the node within the workflow where the edge ends.
                                                                                                                                                                              	DestinationId *string
                                                                                                                                                                              
                                                                                                                                                                              	// The unique of the node within the workflow where the edge starts.
                                                                                                                                                                              	SourceId *string
                                                                                                                                                                              }

                                                                                                                                                                                An edge represents a directed connection between two AWS Glue components that are part of the workflow the edge belongs to.

                                                                                                                                                                                type EnableHybridValues

                                                                                                                                                                                type EnableHybridValues string
                                                                                                                                                                                const (
                                                                                                                                                                                	EnableHybridValuesTrue  EnableHybridValues = "TRUE"
                                                                                                                                                                                	EnableHybridValuesFalse EnableHybridValues = "FALSE"
                                                                                                                                                                                )

                                                                                                                                                                                  Enum values for EnableHybridValues

                                                                                                                                                                                  func (EnableHybridValues) Values

                                                                                                                                                                                    Values returns all known values for EnableHybridValues. 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 EncryptionAtRest

                                                                                                                                                                                    type EncryptionAtRest struct {
                                                                                                                                                                                    
                                                                                                                                                                                    	// The encryption-at-rest mode for encrypting Data Catalog data.
                                                                                                                                                                                    	//
                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                    	CatalogEncryptionMode CatalogEncryptionMode
                                                                                                                                                                                    
                                                                                                                                                                                    	// The ID of the AWS KMS key to use for encryption at rest.
                                                                                                                                                                                    	SseAwsKmsKeyId *string
                                                                                                                                                                                    }

                                                                                                                                                                                      Specifies the encryption-at-rest configuration for the Data Catalog.

                                                                                                                                                                                      type EncryptionConfiguration

                                                                                                                                                                                      type EncryptionConfiguration struct {
                                                                                                                                                                                      
                                                                                                                                                                                      	// The encryption configuration for Amazon CloudWatch.
                                                                                                                                                                                      	CloudWatchEncryption *CloudWatchEncryption
                                                                                                                                                                                      
                                                                                                                                                                                      	// The encryption configuration for job bookmarks.
                                                                                                                                                                                      	JobBookmarksEncryption *JobBookmarksEncryption
                                                                                                                                                                                      
                                                                                                                                                                                      	// The encryption configuration for Amazon Simple Storage Service (Amazon S3) data.
                                                                                                                                                                                      	S3Encryption []S3Encryption
                                                                                                                                                                                      }

                                                                                                                                                                                        Specifies an encryption configuration.

                                                                                                                                                                                        type EntityNotFoundException

                                                                                                                                                                                        type EntityNotFoundException struct {
                                                                                                                                                                                        	Message *string
                                                                                                                                                                                        }

                                                                                                                                                                                          A specified entity does not exist

                                                                                                                                                                                          func (*EntityNotFoundException) Error

                                                                                                                                                                                          func (e *EntityNotFoundException) Error() string

                                                                                                                                                                                          func (*EntityNotFoundException) ErrorCode

                                                                                                                                                                                          func (e *EntityNotFoundException) ErrorCode() string

                                                                                                                                                                                          func (*EntityNotFoundException) ErrorFault

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

                                                                                                                                                                                          func (*EntityNotFoundException) ErrorMessage

                                                                                                                                                                                          func (e *EntityNotFoundException) ErrorMessage() string

                                                                                                                                                                                          type ErrorDetail

                                                                                                                                                                                          type ErrorDetail struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The code associated with this error.
                                                                                                                                                                                          	ErrorCode *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// A message describing the error.
                                                                                                                                                                                          	ErrorMessage *string
                                                                                                                                                                                          }

                                                                                                                                                                                            Contains details about an error.

                                                                                                                                                                                            type ErrorDetails

                                                                                                                                                                                            type ErrorDetails struct {
                                                                                                                                                                                            
                                                                                                                                                                                            	// The error code for an error.
                                                                                                                                                                                            	ErrorCode *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// The error message for an error.
                                                                                                                                                                                            	ErrorMessage *string
                                                                                                                                                                                            }

                                                                                                                                                                                              An object containing error details.

                                                                                                                                                                                              type EvaluationMetrics

                                                                                                                                                                                              type EvaluationMetrics struct {
                                                                                                                                                                                              
                                                                                                                                                                                              	// The type of machine learning transform.
                                                                                                                                                                                              	//
                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                              	TransformType TransformType
                                                                                                                                                                                              
                                                                                                                                                                                              	// The evaluation metrics for the find matches algorithm.
                                                                                                                                                                                              	FindMatchesMetrics *FindMatchesMetrics
                                                                                                                                                                                              }

                                                                                                                                                                                                Evaluation metrics provide an estimate of the quality of your machine learning transform.

                                                                                                                                                                                                type ExecutionProperty

                                                                                                                                                                                                type ExecutionProperty struct {
                                                                                                                                                                                                
                                                                                                                                                                                                	// The maximum number of concurrent runs allowed for the job. The default is 1. An
                                                                                                                                                                                                	// error is returned when this threshold is reached. The maximum value you can
                                                                                                                                                                                                	// specify is controlled by a service limit.
                                                                                                                                                                                                	MaxConcurrentRuns int32
                                                                                                                                                                                                }

                                                                                                                                                                                                  An execution property of a job.

                                                                                                                                                                                                  type ExistCondition

                                                                                                                                                                                                  type ExistCondition string
                                                                                                                                                                                                  const (
                                                                                                                                                                                                  	ExistConditionMustExist ExistCondition = "MUST_EXIST"
                                                                                                                                                                                                  	ExistConditionNotExist  ExistCondition = "NOT_EXIST"
                                                                                                                                                                                                  	ExistConditionNone      ExistCondition = "NONE"
                                                                                                                                                                                                  )

                                                                                                                                                                                                    Enum values for ExistCondition

                                                                                                                                                                                                    func (ExistCondition) Values

                                                                                                                                                                                                    func (ExistCondition) Values() []ExistCondition

                                                                                                                                                                                                      Values returns all known values for ExistCondition. 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 ExportLabelsTaskRunProperties

                                                                                                                                                                                                      type ExportLabelsTaskRunProperties struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The Amazon Simple Storage Service (Amazon S3) path where you will export the
                                                                                                                                                                                                      	// labels.
                                                                                                                                                                                                      	OutputS3Path *string
                                                                                                                                                                                                      }

                                                                                                                                                                                                        Specifies configuration properties for an exporting labels task run.

                                                                                                                                                                                                        type FindMatchesMetrics

                                                                                                                                                                                                        type FindMatchesMetrics struct {
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The area under the precision/recall curve (AUPRC) is a single number measuring
                                                                                                                                                                                                        	// the overall quality of the transform, that is independent of the choice made for
                                                                                                                                                                                                        	// precision vs. recall. Higher values indicate that you have a more attractive
                                                                                                                                                                                                        	// precision vs. recall tradeoff. For more information, see Precision and recall
                                                                                                                                                                                                        	// (https://en.wikipedia.org/wiki/Precision_and_recall) in Wikipedia.
                                                                                                                                                                                                        	AreaUnderPRCurve *float64
                                                                                                                                                                                                        
                                                                                                                                                                                                        	ColumnImportances []ColumnImportance
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The confusion matrix shows you what your transform is predicting accurately and
                                                                                                                                                                                                        	// what types of errors it is making. For more information, see Confusion matrix
                                                                                                                                                                                                        	// (https://en.wikipedia.org/wiki/Confusion_matrix) in Wikipedia.
                                                                                                                                                                                                        	ConfusionMatrix *ConfusionMatrix
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The maximum F1 metric indicates the transform's accuracy between 0 and 1, where
                                                                                                                                                                                                        	// 1 is the best accuracy. For more information, see F1 score
                                                                                                                                                                                                        	// (https://en.wikipedia.org/wiki/F1_score) in Wikipedia.
                                                                                                                                                                                                        	F1 *float64
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The precision metric indicates when often your transform is correct when it
                                                                                                                                                                                                        	// predicts a match. Specifically, it measures how well the transform finds true
                                                                                                                                                                                                        	// positives from the total true positives possible. For more information, see
                                                                                                                                                                                                        	// Precision and recall (https://en.wikipedia.org/wiki/Precision_and_recall) in
                                                                                                                                                                                                        	// Wikipedia.
                                                                                                                                                                                                        	Precision *float64
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The recall metric indicates that for an actual match, how often your transform
                                                                                                                                                                                                        	// predicts the match. Specifically, it measures how well the transform finds true
                                                                                                                                                                                                        	// positives from the total records in the source data. For more information, see
                                                                                                                                                                                                        	// Precision and recall (https://en.wikipedia.org/wiki/Precision_and_recall) in
                                                                                                                                                                                                        	// Wikipedia.
                                                                                                                                                                                                        	Recall *float64
                                                                                                                                                                                                        }

                                                                                                                                                                                                          The evaluation metrics for the find matches algorithm. The quality of your machine learning transform is measured by getting your transform to predict some matches and comparing the results to known matches from the same dataset. The quality metrics are based on a subset of your data, so they are not precise.

                                                                                                                                                                                                          type FindMatchesParameters

                                                                                                                                                                                                          type FindMatchesParameters struct {
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The value that is selected when tuning your transform for a balance between
                                                                                                                                                                                                          	// accuracy and cost. A value of 0.5 means that the system balances accuracy and
                                                                                                                                                                                                          	// cost concerns. A value of 1.0 means a bias purely for accuracy, which typically
                                                                                                                                                                                                          	// results in a higher cost, sometimes substantially higher. A value of 0.0 means a
                                                                                                                                                                                                          	// bias purely for cost, which results in a less accurate FindMatches transform,
                                                                                                                                                                                                          	// sometimes with unacceptable accuracy. Accuracy measures how well the transform
                                                                                                                                                                                                          	// finds true positives and true negatives. Increasing accuracy requires more
                                                                                                                                                                                                          	// machine resources and cost. But it also results in increased recall. Cost
                                                                                                                                                                                                          	// measures how many compute resources, and thus money, are consumed to run the
                                                                                                                                                                                                          	// transform.
                                                                                                                                                                                                          	AccuracyCostTradeoff *float64
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The value to switch on or off to force the output to match the provided labels
                                                                                                                                                                                                          	// from users. If the value is True, the find matches transform forces the output
                                                                                                                                                                                                          	// to match the provided labels. The results override the normal conflation
                                                                                                                                                                                                          	// results. If the value is False, the find matches transform does not ensure all
                                                                                                                                                                                                          	// the labels provided are respected, and the results rely on the trained model.
                                                                                                                                                                                                          	// Note that setting this value to true may increase the conflation execution time.
                                                                                                                                                                                                          	EnforceProvidedLabels *bool
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The value selected when tuning your transform for a balance between precision
                                                                                                                                                                                                          	// and recall. A value of 0.5 means no preference; a value of 1.0 means a bias
                                                                                                                                                                                                          	// purely for precision, and a value of 0.0 means a bias for recall. Because this
                                                                                                                                                                                                          	// is a tradeoff, choosing values close to 1.0 means very low recall, and choosing
                                                                                                                                                                                                          	// values close to 0.0 results in very low precision. The precision metric
                                                                                                                                                                                                          	// indicates how often your model is correct when it predicts a match. The recall
                                                                                                                                                                                                          	// metric indicates that for an actual match, how often your model predicts the
                                                                                                                                                                                                          	// match.
                                                                                                                                                                                                          	PrecisionRecallTradeoff *float64
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The name of a column that uniquely identifies rows in the source table. Used to
                                                                                                                                                                                                          	// help identify matching records.
                                                                                                                                                                                                          	PrimaryKeyColumnName *string
                                                                                                                                                                                                          }

                                                                                                                                                                                                            The parameters to configure the find matches transform.

                                                                                                                                                                                                            type FindMatchesTaskRunProperties

                                                                                                                                                                                                            type FindMatchesTaskRunProperties struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The job ID for the Find Matches task run.
                                                                                                                                                                                                            	JobId *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The name assigned to the job for the Find Matches task run.
                                                                                                                                                                                                            	JobName *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The job run ID for the Find Matches task run.
                                                                                                                                                                                                            	JobRunId *string
                                                                                                                                                                                                            }

                                                                                                                                                                                                              Specifies configuration properties for a Find Matches task run.

                                                                                                                                                                                                              type GetConnectionsFilter

                                                                                                                                                                                                              type GetConnectionsFilter struct {
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// The type of connections to return. Currently, SFTP is not supported.
                                                                                                                                                                                                              	ConnectionType ConnectionType
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// A criteria string that must match the criteria recorded in the connection
                                                                                                                                                                                                              	// definition for that connection definition to be returned.
                                                                                                                                                                                                              	MatchCriteria []string
                                                                                                                                                                                                              }

                                                                                                                                                                                                                Filters the connection definitions that are returned by the GetConnections API operation.

                                                                                                                                                                                                                type GlueEncryptionException

                                                                                                                                                                                                                type GlueEncryptionException struct {
                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                }

                                                                                                                                                                                                                  An encryption operation failed.

                                                                                                                                                                                                                  func (*GlueEncryptionException) Error

                                                                                                                                                                                                                  func (e *GlueEncryptionException) Error() string

                                                                                                                                                                                                                  func (*GlueEncryptionException) ErrorCode

                                                                                                                                                                                                                  func (e *GlueEncryptionException) ErrorCode() string

                                                                                                                                                                                                                  func (*GlueEncryptionException) ErrorFault

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

                                                                                                                                                                                                                  func (*GlueEncryptionException) ErrorMessage

                                                                                                                                                                                                                  func (e *GlueEncryptionException) ErrorMessage() string

                                                                                                                                                                                                                  type GluePolicy

                                                                                                                                                                                                                  type GluePolicy struct {
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// The date and time at which the policy was created.
                                                                                                                                                                                                                  	CreateTime *time.Time
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// Contains the hash value associated with this policy.
                                                                                                                                                                                                                  	PolicyHash *string
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// Contains the requested policy document, in JSON format.
                                                                                                                                                                                                                  	PolicyInJson *string
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// The date and time at which the policy was last updated.
                                                                                                                                                                                                                  	UpdateTime *time.Time
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                    A structure for returning a resource policy.

                                                                                                                                                                                                                    type GlueTable

                                                                                                                                                                                                                    type GlueTable struct {
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// A database name in the AWS Glue Data Catalog.
                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                    	DatabaseName *string
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// A table name in the AWS Glue Data Catalog.
                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                    	TableName *string
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// A unique identifier for the AWS Glue Data Catalog.
                                                                                                                                                                                                                    	CatalogId *string
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// The name of the connection to the AWS Glue Data Catalog.
                                                                                                                                                                                                                    	ConnectionName *string
                                                                                                                                                                                                                    }

                                                                                                                                                                                                                      The database and table in the AWS Glue Data Catalog that is used for input or output data.

                                                                                                                                                                                                                      type GrokClassifier

                                                                                                                                                                                                                      type GrokClassifier struct {
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// An identifier of the data format that the classifier matches, such as Twitter,
                                                                                                                                                                                                                      	// JSON, Omniture logs, and so on.
                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                      	Classification *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The grok pattern applied to a data store by this classifier. For more
                                                                                                                                                                                                                      	// information, see built-in patterns in Writing Custom Classifiers
                                                                                                                                                                                                                      	// (https://docs.aws.amazon.com/glue/latest/dg/custom-classifier.html).
                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                      	GrokPattern *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The name of the classifier.
                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                      	Name *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The time that this classifier was registered.
                                                                                                                                                                                                                      	CreationTime *time.Time
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Optional custom grok patterns defined by this classifier. For more information,
                                                                                                                                                                                                                      	// see custom patterns in Writing Custom Classifiers
                                                                                                                                                                                                                      	// (https://docs.aws.amazon.com/glue/latest/dg/custom-classifier.html).
                                                                                                                                                                                                                      	CustomPatterns *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The time that this classifier was last updated.
                                                                                                                                                                                                                      	LastUpdated *time.Time
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The version of this classifier.
                                                                                                                                                                                                                      	Version int64
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        A classifier that uses grok patterns.

                                                                                                                                                                                                                        type IdempotentParameterMismatchException

                                                                                                                                                                                                                        type IdempotentParameterMismatchException struct {
                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                          The same unique identifier was associated with two different records.

                                                                                                                                                                                                                          func (*IdempotentParameterMismatchException) Error

                                                                                                                                                                                                                          func (*IdempotentParameterMismatchException) ErrorCode

                                                                                                                                                                                                                          func (*IdempotentParameterMismatchException) ErrorFault

                                                                                                                                                                                                                          func (*IdempotentParameterMismatchException) ErrorMessage

                                                                                                                                                                                                                          func (e *IdempotentParameterMismatchException) ErrorMessage() string

                                                                                                                                                                                                                          type IllegalWorkflowStateException

                                                                                                                                                                                                                          type IllegalWorkflowStateException struct {
                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                          }

                                                                                                                                                                                                                            The workflow is in an invalid state to perform a requested operation.

                                                                                                                                                                                                                            func (*IllegalWorkflowStateException) Error

                                                                                                                                                                                                                            func (*IllegalWorkflowStateException) ErrorCode

                                                                                                                                                                                                                            func (e *IllegalWorkflowStateException) ErrorCode() string

                                                                                                                                                                                                                            func (*IllegalWorkflowStateException) ErrorFault

                                                                                                                                                                                                                            func (*IllegalWorkflowStateException) ErrorMessage

                                                                                                                                                                                                                            func (e *IllegalWorkflowStateException) ErrorMessage() string

                                                                                                                                                                                                                            type ImportLabelsTaskRunProperties

                                                                                                                                                                                                                            type ImportLabelsTaskRunProperties struct {
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// The Amazon Simple Storage Service (Amazon S3) path from where you will import
                                                                                                                                                                                                                            	// the labels.
                                                                                                                                                                                                                            	InputS3Path *string
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// Indicates whether to overwrite your existing labels.
                                                                                                                                                                                                                            	Replace bool
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                              Specifies configuration properties for an importing labels task run.

                                                                                                                                                                                                                              type InternalServiceException

                                                                                                                                                                                                                              type InternalServiceException struct {
                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                An internal service error occurred.

                                                                                                                                                                                                                                func (*InternalServiceException) Error

                                                                                                                                                                                                                                func (e *InternalServiceException) Error() string

                                                                                                                                                                                                                                func (*InternalServiceException) ErrorCode

                                                                                                                                                                                                                                func (e *InternalServiceException) ErrorCode() string

                                                                                                                                                                                                                                func (*InternalServiceException) ErrorFault

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

                                                                                                                                                                                                                                func (*InternalServiceException) ErrorMessage

                                                                                                                                                                                                                                func (e *InternalServiceException) ErrorMessage() string

                                                                                                                                                                                                                                type InvalidInputException

                                                                                                                                                                                                                                type InvalidInputException struct {
                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                  The input provided was not valid.

                                                                                                                                                                                                                                  func (*InvalidInputException) Error

                                                                                                                                                                                                                                  func (e *InvalidInputException) Error() string

                                                                                                                                                                                                                                  func (*InvalidInputException) ErrorCode

                                                                                                                                                                                                                                  func (e *InvalidInputException) ErrorCode() string

                                                                                                                                                                                                                                  func (*InvalidInputException) ErrorFault

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

                                                                                                                                                                                                                                  func (*InvalidInputException) ErrorMessage

                                                                                                                                                                                                                                  func (e *InvalidInputException) ErrorMessage() string

                                                                                                                                                                                                                                  type JdbcTarget

                                                                                                                                                                                                                                  type JdbcTarget struct {
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The name of the connection to use to connect to the JDBC target.
                                                                                                                                                                                                                                  	ConnectionName *string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// A list of glob patterns used to exclude from the crawl. For more information,
                                                                                                                                                                                                                                  	// see Catalog Tables with a Crawler
                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/glue/latest/dg/add-crawler.html).
                                                                                                                                                                                                                                  	Exclusions []string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The path of the JDBC target.
                                                                                                                                                                                                                                  	Path *string
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                    Specifies a JDBC data store to crawl.

                                                                                                                                                                                                                                    type Job

                                                                                                                                                                                                                                    type Job struct {
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// This field is deprecated. Use MaxCapacity instead. The number of AWS Glue data
                                                                                                                                                                                                                                    	// processing units (DPUs) allocated to runs of this job. You can allocate from 2
                                                                                                                                                                                                                                    	// to 100 DPUs; the default is 10. A DPU is a relative measure of processing power
                                                                                                                                                                                                                                    	// that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more
                                                                                                                                                                                                                                    	// information, see the AWS Glue pricing page
                                                                                                                                                                                                                                    	// (https://aws.amazon.com/glue/pricing/).
                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                    	// Deprecated: This property is deprecated, use MaxCapacity instead.
                                                                                                                                                                                                                                    	AllocatedCapacity int32
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The JobCommand that executes this job.
                                                                                                                                                                                                                                    	Command *JobCommand
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The connections used for this job.
                                                                                                                                                                                                                                    	Connections *ConnectionsList
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The time and date that this job definition was created.
                                                                                                                                                                                                                                    	CreatedOn *time.Time
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The default arguments for this job, specified as name-value pairs. You can
                                                                                                                                                                                                                                    	// specify arguments here that your own job-execution script consumes, as well as
                                                                                                                                                                                                                                    	// arguments that AWS Glue itself consumes. For information about how to specify
                                                                                                                                                                                                                                    	// and consume your own Job arguments, see the Calling AWS Glue APIs in Python
                                                                                                                                                                                                                                    	// (https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-calling.html)
                                                                                                                                                                                                                                    	// topic in the developer guide. For information about the key-value pairs that AWS
                                                                                                                                                                                                                                    	// Glue consumes to set up your job, see the Special Parameters Used by AWS Glue
                                                                                                                                                                                                                                    	// (https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html)
                                                                                                                                                                                                                                    	// topic in the developer guide.
                                                                                                                                                                                                                                    	DefaultArguments map[string]string
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// A description of the job.
                                                                                                                                                                                                                                    	Description *string
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// An ExecutionProperty specifying the maximum number of concurrent runs allowed
                                                                                                                                                                                                                                    	// for this job.
                                                                                                                                                                                                                                    	ExecutionProperty *ExecutionProperty
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// Glue version determines the versions of Apache Spark and Python that AWS Glue
                                                                                                                                                                                                                                    	// supports. The Python version indicates the version supported for jobs of type
                                                                                                                                                                                                                                    	// Spark. For more information about the available AWS Glue versions and
                                                                                                                                                                                                                                    	// corresponding Spark and Python versions, see Glue version
                                                                                                                                                                                                                                    	// (https://docs.aws.amazon.com/glue/latest/dg/add-job.html) in the developer
                                                                                                                                                                                                                                    	// guide. Jobs that are created without specifying a Glue version default to Glue
                                                                                                                                                                                                                                    	// 0.9.
                                                                                                                                                                                                                                    	GlueVersion *string
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The last point in time when this job definition was modified.
                                                                                                                                                                                                                                    	LastModifiedOn *time.Time
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// This field is reserved for future use.
                                                                                                                                                                                                                                    	LogUri *string
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The number of AWS Glue data processing units (DPUs) that can be allocated when
                                                                                                                                                                                                                                    	// this job runs. A DPU is a relative measure of processing power that consists of
                                                                                                                                                                                                                                    	// 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the
                                                                                                                                                                                                                                    	// AWS Glue pricing page (https://aws.amazon.com/glue/pricing/). Do not set Max
                                                                                                                                                                                                                                    	// Capacity if using WorkerType and NumberOfWorkers. The value that can be
                                                                                                                                                                                                                                    	// allocated for MaxCapacity depends on whether you are running a Python shell job,
                                                                                                                                                                                                                                    	// an Apache Spark ETL job, or an Apache Spark streaming ETL job:
                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                    	// * When you
                                                                                                                                                                                                                                    	// specify a Python shell job (JobCommand.Name="pythonshell"), you can allocate
                                                                                                                                                                                                                                    	// either 0.0625 or 1 DPU. The default is 0.0625 DPU.
                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                    	// * When you specify an Apache
                                                                                                                                                                                                                                    	// Spark ETL job (JobCommand.Name="glueetl") or Apache Spark streaming ETL job
                                                                                                                                                                                                                                    	// (JobCommand.Name="gluestreaming"), you can allocate from 2 to 100 DPUs. The
                                                                                                                                                                                                                                    	// default is 10 DPUs. This job type cannot have a fractional DPU allocation.
                                                                                                                                                                                                                                    	MaxCapacity *float64
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The maximum number of times to retry this job after a JobRun fails.
                                                                                                                                                                                                                                    	MaxRetries int32
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The name you assign to this job definition.
                                                                                                                                                                                                                                    	Name *string
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// Non-overridable arguments for this job, specified as name-value pairs.
                                                                                                                                                                                                                                    	NonOverridableArguments map[string]string
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// Specifies configuration properties of a job notification.
                                                                                                                                                                                                                                    	NotificationProperty *NotificationProperty
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The number of workers of a defined workerType that are allocated when a job
                                                                                                                                                                                                                                    	// runs. The maximum number of workers you can define are 299 for G.1X, and 149 for
                                                                                                                                                                                                                                    	// G.2X.
                                                                                                                                                                                                                                    	NumberOfWorkers *int32
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The name or Amazon Resource Name (ARN) of the IAM role associated with this job.
                                                                                                                                                                                                                                    	Role *string
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The name of the SecurityConfiguration structure to be used with this job.
                                                                                                                                                                                                                                    	SecurityConfiguration *string
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The job timeout in minutes. This is the maximum time that a job run can consume
                                                                                                                                                                                                                                    	// resources before it is terminated and enters TIMEOUT status. The default is
                                                                                                                                                                                                                                    	// 2,880 minutes (48 hours).
                                                                                                                                                                                                                                    	Timeout *int32
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The type of predefined worker that is allocated when a job runs. Accepts a value
                                                                                                                                                                                                                                    	// of Standard, G.1X, or G.2X.
                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                    	// * For the Standard worker type, each worker
                                                                                                                                                                                                                                    	// provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.
                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                    	// *
                                                                                                                                                                                                                                    	// For the G.1X worker type, each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64
                                                                                                                                                                                                                                    	// GB disk), and provides 1 executor per worker. We recommend this worker type for
                                                                                                                                                                                                                                    	// memory-intensive jobs.
                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                    	// * For the G.2X worker type, each worker maps to 2 DPU (8
                                                                                                                                                                                                                                    	// vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per worker. We
                                                                                                                                                                                                                                    	// recommend this worker type for memory-intensive jobs.
                                                                                                                                                                                                                                    	WorkerType WorkerType
                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                      Specifies a job definition.

                                                                                                                                                                                                                                      type JobBookmarkEntry

                                                                                                                                                                                                                                      type JobBookmarkEntry struct {
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The attempt ID number.
                                                                                                                                                                                                                                      	Attempt int32
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The bookmark itself.
                                                                                                                                                                                                                                      	JobBookmark *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The name of the job in question.
                                                                                                                                                                                                                                      	JobName *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The unique run identifier associated with the previous job run.
                                                                                                                                                                                                                                      	PreviousRunId *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The run ID number.
                                                                                                                                                                                                                                      	Run int32
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The run ID number.
                                                                                                                                                                                                                                      	RunId *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The version of the job.
                                                                                                                                                                                                                                      	Version int32
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        Defines a point that a job can resume processing.

                                                                                                                                                                                                                                        type JobBookmarksEncryption

                                                                                                                                                                                                                                        type JobBookmarksEncryption struct {
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// The encryption mode to use for job bookmarks data.
                                                                                                                                                                                                                                        	JobBookmarksEncryptionMode JobBookmarksEncryptionMode
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// The Amazon Resource Name (ARN) of the KMS key to be used to encrypt the data.
                                                                                                                                                                                                                                        	KmsKeyArn *string
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                          Specifies how job bookmark data should be encrypted.

                                                                                                                                                                                                                                          type JobBookmarksEncryptionMode

                                                                                                                                                                                                                                          type JobBookmarksEncryptionMode string
                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                          	JobBookmarksEncryptionModeDisabled JobBookmarksEncryptionMode = "DISABLED"
                                                                                                                                                                                                                                          	JobBookmarksEncryptionModeCsekms   JobBookmarksEncryptionMode = "CSE-KMS"
                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                            Enum values for JobBookmarksEncryptionMode

                                                                                                                                                                                                                                            func (JobBookmarksEncryptionMode) Values

                                                                                                                                                                                                                                              Values returns all known values for JobBookmarksEncryptionMode. 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 JobCommand

                                                                                                                                                                                                                                              type JobCommand struct {
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The name of the job command. For an Apache Spark ETL job, this must be glueetl.
                                                                                                                                                                                                                                              	// For a Python shell job, it must be pythonshell. For an Apache Spark streaming
                                                                                                                                                                                                                                              	// ETL job, this must be gluestreaming.
                                                                                                                                                                                                                                              	Name *string
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The Python version being used to execute a Python shell job. Allowed values are
                                                                                                                                                                                                                                              	// 2 or 3.
                                                                                                                                                                                                                                              	PythonVersion *string
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// Specifies the Amazon Simple Storage Service (Amazon S3) path to a script that
                                                                                                                                                                                                                                              	// executes a job.
                                                                                                                                                                                                                                              	ScriptLocation *string
                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                Specifies code executed when a job is run.

                                                                                                                                                                                                                                                type JobNodeDetails

                                                                                                                                                                                                                                                type JobNodeDetails struct {
                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                	// The information for the job runs represented by the job node.
                                                                                                                                                                                                                                                	JobRuns []JobRun
                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                  The details of a Job node present in the workflow.

                                                                                                                                                                                                                                                  type JobRun

                                                                                                                                                                                                                                                  type JobRun struct {
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// This field is deprecated. Use MaxCapacity instead. The number of AWS Glue data
                                                                                                                                                                                                                                                  	// processing units (DPUs) allocated to this JobRun. From 2 to 100 DPUs can be
                                                                                                                                                                                                                                                  	// allocated; the default is 10. A DPU is a relative measure of processing power
                                                                                                                                                                                                                                                  	// that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more
                                                                                                                                                                                                                                                  	// information, see the AWS Glue pricing page
                                                                                                                                                                                                                                                  	// (https://aws.amazon.com/glue/pricing/).
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// Deprecated: This property is deprecated, use MaxCapacity instead.
                                                                                                                                                                                                                                                  	AllocatedCapacity int32
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The job arguments associated with this run. For this job run, they replace the
                                                                                                                                                                                                                                                  	// default arguments set in the job definition itself. You can specify arguments
                                                                                                                                                                                                                                                  	// here that your own job-execution script consumes, as well as arguments that AWS
                                                                                                                                                                                                                                                  	// Glue itself consumes. For information about how to specify and consume your own
                                                                                                                                                                                                                                                  	// job arguments, see the Calling AWS Glue APIs in Python
                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-calling.html)
                                                                                                                                                                                                                                                  	// topic in the developer guide. For information about the key-value pairs that AWS
                                                                                                                                                                                                                                                  	// Glue consumes to set up your job, see the Special Parameters Used by AWS Glue
                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html)
                                                                                                                                                                                                                                                  	// topic in the developer guide.
                                                                                                                                                                                                                                                  	Arguments map[string]string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The number of the attempt to run this job.
                                                                                                                                                                                                                                                  	Attempt int32
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The date and time that this job run completed.
                                                                                                                                                                                                                                                  	CompletedOn *time.Time
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// An error message associated with this job run.
                                                                                                                                                                                                                                                  	ErrorMessage *string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The amount of time (in seconds) that the job run consumed resources.
                                                                                                                                                                                                                                                  	ExecutionTime int32
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// Glue version determines the versions of Apache Spark and Python that AWS Glue
                                                                                                                                                                                                                                                  	// supports. The Python version indicates the version supported for jobs of type
                                                                                                                                                                                                                                                  	// Spark. For more information about the available AWS Glue versions and
                                                                                                                                                                                                                                                  	// corresponding Spark and Python versions, see Glue version
                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/glue/latest/dg/add-job.html) in the developer
                                                                                                                                                                                                                                                  	// guide. Jobs that are created without specifying a Glue version default to Glue
                                                                                                                                                                                                                                                  	// 0.9.
                                                                                                                                                                                                                                                  	GlueVersion *string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The ID of this job run.
                                                                                                                                                                                                                                                  	Id *string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The name of the job definition being used in this run.
                                                                                                                                                                                                                                                  	JobName *string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The current state of the job run. For more information about the statuses of
                                                                                                                                                                                                                                                  	// jobs that have terminated abnormally, see AWS Glue Job Run Statuses
                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/glue/latest/dg/job-run-statuses.html).
                                                                                                                                                                                                                                                  	JobRunState JobRunState
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The last time that this job run was modified.
                                                                                                                                                                                                                                                  	LastModifiedOn *time.Time
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The name of the log group for secure logging that can be server-side encrypted
                                                                                                                                                                                                                                                  	// in Amazon CloudWatch using AWS KMS. This name can be /aws-glue/jobs/, in which
                                                                                                                                                                                                                                                  	// case the default encryption is NONE. If you add a role name and
                                                                                                                                                                                                                                                  	// SecurityConfiguration name (in other words,
                                                                                                                                                                                                                                                  	// /aws-glue/jobs-yourRoleName-yourSecurityConfigurationName/), then that security
                                                                                                                                                                                                                                                  	// configuration is used to encrypt the log group.
                                                                                                                                                                                                                                                  	LogGroupName *string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The number of AWS Glue data processing units (DPUs) that can be allocated when
                                                                                                                                                                                                                                                  	// this job runs. A DPU is a relative measure of processing power that consists of
                                                                                                                                                                                                                                                  	// 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the
                                                                                                                                                                                                                                                  	// AWS Glue pricing page
                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/https:/aws.amazon.com/glue/pricing/). Do not set
                                                                                                                                                                                                                                                  	// Max Capacity if using WorkerType and NumberOfWorkers. The value that can be
                                                                                                                                                                                                                                                  	// allocated for MaxCapacity depends on whether you are running a Python shell job
                                                                                                                                                                                                                                                  	// or an Apache Spark ETL job:
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// * When you specify a Python shell job
                                                                                                                                                                                                                                                  	// (JobCommand.Name="pythonshell"), you can allocate either 0.0625 or 1 DPU. The
                                                                                                                                                                                                                                                  	// default is 0.0625 DPU.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// * When you specify an Apache Spark ETL job
                                                                                                                                                                                                                                                  	// (JobCommand.Name="glueetl"), you can allocate from 2 to 100 DPUs. The default is
                                                                                                                                                                                                                                                  	// 10 DPUs. This job type cannot have a fractional DPU allocation.
                                                                                                                                                                                                                                                  	MaxCapacity *float64
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// Specifies configuration properties of a job run notification.
                                                                                                                                                                                                                                                  	NotificationProperty *NotificationProperty
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The number of workers of a defined workerType that are allocated when a job
                                                                                                                                                                                                                                                  	// runs. The maximum number of workers you can define are 299 for G.1X, and 149 for
                                                                                                                                                                                                                                                  	// G.2X.
                                                                                                                                                                                                                                                  	NumberOfWorkers *int32
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// A list of predecessors to this job run.
                                                                                                                                                                                                                                                  	PredecessorRuns []Predecessor
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The ID of the previous run of this job. For example, the JobRunId specified in
                                                                                                                                                                                                                                                  	// the StartJobRun action.
                                                                                                                                                                                                                                                  	PreviousRunId *string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The name of the SecurityConfiguration structure to be used with this job run.
                                                                                                                                                                                                                                                  	SecurityConfiguration *string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The date and time at which this job run was started.
                                                                                                                                                                                                                                                  	StartedOn *time.Time
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The JobRun timeout in minutes. This is the maximum time that a job run can
                                                                                                                                                                                                                                                  	// consume resources before it is terminated and enters TIMEOUT status. The default
                                                                                                                                                                                                                                                  	// is 2,880 minutes (48 hours). This overrides the timeout value set in the parent
                                                                                                                                                                                                                                                  	// job.
                                                                                                                                                                                                                                                  	Timeout *int32
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The name of the trigger that started this job run.
                                                                                                                                                                                                                                                  	TriggerName *string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The type of predefined worker that is allocated when a job runs. Accepts a value
                                                                                                                                                                                                                                                  	// of Standard, G.1X, or G.2X.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// * For the Standard worker type, each worker
                                                                                                                                                                                                                                                  	// provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                  	// For the G.1X worker type, each worker provides 4 vCPU, 16 GB of memory and a
                                                                                                                                                                                                                                                  	// 64GB disk, and 1 executor per worker.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// * For the G.2X worker type, each worker
                                                                                                                                                                                                                                                  	// provides 8 vCPU, 32 GB of memory and a 128GB disk, and 1 executor per worker.
                                                                                                                                                                                                                                                  	WorkerType WorkerType
                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                    Contains information about a job run.

                                                                                                                                                                                                                                                    type JobRunState

                                                                                                                                                                                                                                                    type JobRunState string
                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                    	JobRunStateStarting  JobRunState = "STARTING"
                                                                                                                                                                                                                                                    	JobRunStateRunning   JobRunState = "RUNNING"
                                                                                                                                                                                                                                                    	JobRunStateStopping  JobRunState = "STOPPING"
                                                                                                                                                                                                                                                    	JobRunStateStopped   JobRunState = "STOPPED"
                                                                                                                                                                                                                                                    	JobRunStateSucceeded JobRunState = "SUCCEEDED"
                                                                                                                                                                                                                                                    	JobRunStateFailed    JobRunState = "FAILED"
                                                                                                                                                                                                                                                    	JobRunStateTimeout   JobRunState = "TIMEOUT"
                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                      Enum values for JobRunState

                                                                                                                                                                                                                                                      func (JobRunState) Values

                                                                                                                                                                                                                                                      func (JobRunState) Values() []JobRunState

                                                                                                                                                                                                                                                        Values returns all known values for JobRunState. 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 JobUpdate

                                                                                                                                                                                                                                                        type JobUpdate struct {
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// This field is deprecated. Use MaxCapacity instead. The number of AWS Glue data
                                                                                                                                                                                                                                                        	// processing units (DPUs) to allocate to this job. You can allocate from 2 to 100
                                                                                                                                                                                                                                                        	// DPUs; the default is 10. A DPU is a relative measure of processing power that
                                                                                                                                                                                                                                                        	// consists of 4 vCPUs of compute capacity and 16 GB of memory. For more
                                                                                                                                                                                                                                                        	// information, see the AWS Glue pricing page
                                                                                                                                                                                                                                                        	// (https://aws.amazon.com/glue/pricing/).
                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                        	// Deprecated: This property is deprecated, use MaxCapacity instead.
                                                                                                                                                                                                                                                        	AllocatedCapacity int32
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The JobCommand that executes this job (required).
                                                                                                                                                                                                                                                        	Command *JobCommand
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The connections used for this job.
                                                                                                                                                                                                                                                        	Connections *ConnectionsList
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The default arguments for this job. You can specify arguments here that your own
                                                                                                                                                                                                                                                        	// job-execution script consumes, as well as arguments that AWS Glue itself
                                                                                                                                                                                                                                                        	// consumes. For information about how to specify and consume your own Job
                                                                                                                                                                                                                                                        	// arguments, see the Calling AWS Glue APIs in Python
                                                                                                                                                                                                                                                        	// (https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-calling.html)
                                                                                                                                                                                                                                                        	// topic in the developer guide. For information about the key-value pairs that AWS
                                                                                                                                                                                                                                                        	// Glue consumes to set up your job, see the Special Parameters Used by AWS Glue
                                                                                                                                                                                                                                                        	// (https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html)
                                                                                                                                                                                                                                                        	// topic in the developer guide.
                                                                                                                                                                                                                                                        	DefaultArguments map[string]string
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// Description of the job being defined.
                                                                                                                                                                                                                                                        	Description *string
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// An ExecutionProperty specifying the maximum number of concurrent runs allowed
                                                                                                                                                                                                                                                        	// for this job.
                                                                                                                                                                                                                                                        	ExecutionProperty *ExecutionProperty
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// Glue version determines the versions of Apache Spark and Python that AWS Glue
                                                                                                                                                                                                                                                        	// supports. The Python version indicates the version supported for jobs of type
                                                                                                                                                                                                                                                        	// Spark. For more information about the available AWS Glue versions and
                                                                                                                                                                                                                                                        	// corresponding Spark and Python versions, see Glue version
                                                                                                                                                                                                                                                        	// (https://docs.aws.amazon.com/glue/latest/dg/add-job.html) in the developer
                                                                                                                                                                                                                                                        	// guide.
                                                                                                                                                                                                                                                        	GlueVersion *string
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// This field is reserved for future use.
                                                                                                                                                                                                                                                        	LogUri *string
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The number of AWS Glue data processing units (DPUs) that can be allocated when
                                                                                                                                                                                                                                                        	// this job runs. A DPU is a relative measure of processing power that consists of
                                                                                                                                                                                                                                                        	// 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the
                                                                                                                                                                                                                                                        	// AWS Glue pricing page (https://aws.amazon.com/glue/pricing/). Do not set Max
                                                                                                                                                                                                                                                        	// Capacity if using WorkerType and NumberOfWorkers. The value that can be
                                                                                                                                                                                                                                                        	// allocated for MaxCapacity depends on whether you are running a Python shell job
                                                                                                                                                                                                                                                        	// or an Apache Spark ETL job:
                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                        	// * When you specify a Python shell job
                                                                                                                                                                                                                                                        	// (JobCommand.Name="pythonshell"), you can allocate either 0.0625 or 1 DPU. The
                                                                                                                                                                                                                                                        	// default is 0.0625 DPU.
                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                        	// * When you specify an Apache Spark ETL job
                                                                                                                                                                                                                                                        	// (JobCommand.Name="glueetl") or Apache Spark streaming ETL job
                                                                                                                                                                                                                                                        	// (JobCommand.Name="gluestreaming"), you can allocate from 2 to 100 DPUs. The
                                                                                                                                                                                                                                                        	// default is 10 DPUs. This job type cannot have a fractional DPU allocation.
                                                                                                                                                                                                                                                        	MaxCapacity *float64
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The maximum number of times to retry this job if it fails.
                                                                                                                                                                                                                                                        	MaxRetries int32
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// Non-overridable arguments for this job, specified as name-value pairs.
                                                                                                                                                                                                                                                        	NonOverridableArguments map[string]string
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// Specifies the configuration properties of a job notification.
                                                                                                                                                                                                                                                        	NotificationProperty *NotificationProperty
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The number of workers of a defined workerType that are allocated when a job
                                                                                                                                                                                                                                                        	// runs. The maximum number of workers you can define are 299 for G.1X, and 149 for
                                                                                                                                                                                                                                                        	// G.2X.
                                                                                                                                                                                                                                                        	NumberOfWorkers *int32
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The name or Amazon Resource Name (ARN) of the IAM role associated with this job
                                                                                                                                                                                                                                                        	// (required).
                                                                                                                                                                                                                                                        	Role *string
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The name of the SecurityConfiguration structure to be used with this job.
                                                                                                                                                                                                                                                        	SecurityConfiguration *string
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The job timeout in minutes. This is the maximum time that a job run can consume
                                                                                                                                                                                                                                                        	// resources before it is terminated and enters TIMEOUT status. The default is
                                                                                                                                                                                                                                                        	// 2,880 minutes (48 hours).
                                                                                                                                                                                                                                                        	Timeout *int32
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The type of predefined worker that is allocated when a job runs. Accepts a value
                                                                                                                                                                                                                                                        	// of Standard, G.1X, or G.2X.
                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                        	// * For the Standard worker type, each worker
                                                                                                                                                                                                                                                        	// provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.
                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                        	// *
                                                                                                                                                                                                                                                        	// For the G.1X worker type, each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64
                                                                                                                                                                                                                                                        	// GB disk), and provides 1 executor per worker. We recommend this worker type for
                                                                                                                                                                                                                                                        	// memory-intensive jobs.
                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                        	// * For the G.2X worker type, each worker maps to 2 DPU (8
                                                                                                                                                                                                                                                        	// vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per worker. We
                                                                                                                                                                                                                                                        	// recommend this worker type for memory-intensive jobs.
                                                                                                                                                                                                                                                        	WorkerType WorkerType
                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                          Specifies information used to update an existing job definition. The previous job definition is completely overwritten by this information.

                                                                                                                                                                                                                                                          type JsonClassifier

                                                                                                                                                                                                                                                          type JsonClassifier struct {
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// A JsonPath string defining the JSON data for the classifier to classify. AWS
                                                                                                                                                                                                                                                          	// Glue supports a subset of JsonPath, as described in Writing JsonPath Custom
                                                                                                                                                                                                                                                          	// Classifiers
                                                                                                                                                                                                                                                          	// (https://docs.aws.amazon.com/glue/latest/dg/custom-classifier.html#custom-classifier-json).
                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                          	JsonPath *string
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The name of the classifier.
                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                          	Name *string
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The time that this classifier was registered.
                                                                                                                                                                                                                                                          	CreationTime *time.Time
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The time that this classifier was last updated.
                                                                                                                                                                                                                                                          	LastUpdated *time.Time
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The version of this classifier.
                                                                                                                                                                                                                                                          	Version int64
                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                            A classifier for JSON content.

                                                                                                                                                                                                                                                            type KeySchemaElement

                                                                                                                                                                                                                                                            type KeySchemaElement struct {
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The name of a partition key.
                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                            	Name *string
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The type of a partition key.
                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                            	Type *string
                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                              A partition key pair consisting of a name and a type.

                                                                                                                                                                                                                                                              type LabelingSetGenerationTaskRunProperties

                                                                                                                                                                                                                                                              type LabelingSetGenerationTaskRunProperties struct {
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// The Amazon Simple Storage Service (Amazon S3) path where you will generate the
                                                                                                                                                                                                                                                              	// labeling set.
                                                                                                                                                                                                                                                              	OutputS3Path *string
                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                Specifies configuration properties for a labeling set generation task run.

                                                                                                                                                                                                                                                                type Language

                                                                                                                                                                                                                                                                type Language string
                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                	LanguagePython Language = "PYTHON"
                                                                                                                                                                                                                                                                	LanguageScala  Language = "SCALA"
                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                  Enum values for Language

                                                                                                                                                                                                                                                                  func (Language) Values

                                                                                                                                                                                                                                                                  func (Language) Values() []Language

                                                                                                                                                                                                                                                                    Values returns all known values for Language. 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 LastCrawlInfo

                                                                                                                                                                                                                                                                    type LastCrawlInfo struct {
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// If an error occurred, the error information about the last crawl.
                                                                                                                                                                                                                                                                    	ErrorMessage *string
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// The log group for the last crawl.
                                                                                                                                                                                                                                                                    	LogGroup *string
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// The log stream for the last crawl.
                                                                                                                                                                                                                                                                    	LogStream *string
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// The prefix for a message about this crawl.
                                                                                                                                                                                                                                                                    	MessagePrefix *string
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// The time at which the crawl started.
                                                                                                                                                                                                                                                                    	StartTime *time.Time
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// Status of the last crawl.
                                                                                                                                                                                                                                                                    	Status LastCrawlStatus
                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                      Status and error information about the most recent crawl.

                                                                                                                                                                                                                                                                      type LastCrawlStatus

                                                                                                                                                                                                                                                                      type LastCrawlStatus string
                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                      	LastCrawlStatusSucceeded LastCrawlStatus = "SUCCEEDED"
                                                                                                                                                                                                                                                                      	LastCrawlStatusCancelled LastCrawlStatus = "CANCELLED"
                                                                                                                                                                                                                                                                      	LastCrawlStatusFailed    LastCrawlStatus = "FAILED"
                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                        Enum values for LastCrawlStatus

                                                                                                                                                                                                                                                                        func (LastCrawlStatus) Values

                                                                                                                                                                                                                                                                        func (LastCrawlStatus) Values() []LastCrawlStatus

                                                                                                                                                                                                                                                                          Values returns all known values for LastCrawlStatus. 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 LineageConfiguration

                                                                                                                                                                                                                                                                          type LineageConfiguration struct {
                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                          	// Specifies whether data lineage is enabled for the crawler. Valid values are:
                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                          	// *
                                                                                                                                                                                                                                                                          	// ENABLE: enables data lineage for the crawler
                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                          	// * DISABLE: disables data lineage
                                                                                                                                                                                                                                                                          	// for the crawler
                                                                                                                                                                                                                                                                          	CrawlerLineageSettings CrawlerLineageSettings
                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                            Specifies data lineage configuration settings for the crawler.

                                                                                                                                                                                                                                                                            type Location

                                                                                                                                                                                                                                                                            type Location struct {
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// An Amazon DynamoDB table location.
                                                                                                                                                                                                                                                                            	DynamoDB []CodeGenNodeArg
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// A JDBC location.
                                                                                                                                                                                                                                                                            	Jdbc []CodeGenNodeArg
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// An Amazon Simple Storage Service (Amazon S3) location.
                                                                                                                                                                                                                                                                            	S3 []CodeGenNodeArg
                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                              The location of resources.

                                                                                                                                                                                                                                                                              type Logical

                                                                                                                                                                                                                                                                              type Logical string
                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                              	LogicalAnd Logical = "AND"
                                                                                                                                                                                                                                                                              	LogicalAny Logical = "ANY"
                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                Enum values for Logical

                                                                                                                                                                                                                                                                                func (Logical) Values

                                                                                                                                                                                                                                                                                func (Logical) Values() []Logical

                                                                                                                                                                                                                                                                                  Values returns all known values for Logical. 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 LogicalOperator

                                                                                                                                                                                                                                                                                  type LogicalOperator string
                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                  	LogicalOperatorEquals LogicalOperator = "EQUALS"
                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                    Enum values for LogicalOperator

                                                                                                                                                                                                                                                                                    func (LogicalOperator) Values

                                                                                                                                                                                                                                                                                    func (LogicalOperator) Values() []LogicalOperator

                                                                                                                                                                                                                                                                                      Values returns all known values for LogicalOperator. 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 LongColumnStatisticsData

                                                                                                                                                                                                                                                                                      type LongColumnStatisticsData struct {
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// The number of distinct values in a column.
                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                      	NumberOfDistinctValues int64
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// The number of null values in the column.
                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                      	NumberOfNulls int64
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// The highest value in the column.
                                                                                                                                                                                                                                                                                      	MaximumValue int64
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// The lowest value in the column.
                                                                                                                                                                                                                                                                                      	MinimumValue int64
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        Defines column statistics supported for integer data columns.

                                                                                                                                                                                                                                                                                        type MLTransform

                                                                                                                                                                                                                                                                                        type MLTransform struct {
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// A timestamp. The time and date that this machine learning transform was created.
                                                                                                                                                                                                                                                                                        	CreatedOn *time.Time
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// A user-defined, long-form description text for the machine learning transform.
                                                                                                                                                                                                                                                                                        	// Descriptions are not guaranteed to be unique and can be changed at any time.
                                                                                                                                                                                                                                                                                        	Description *string
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// An EvaluationMetrics object. Evaluation metrics provide an estimate of the
                                                                                                                                                                                                                                                                                        	// quality of your machine learning transform.
                                                                                                                                                                                                                                                                                        	EvaluationMetrics *EvaluationMetrics
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// This value determines which version of AWS Glue this machine learning transform
                                                                                                                                                                                                                                                                                        	// is compatible with. Glue 1.0 is recommended for most customers. If the value is
                                                                                                                                                                                                                                                                                        	// not set, the Glue compatibility defaults to Glue 0.9. For more information, see
                                                                                                                                                                                                                                                                                        	// AWS Glue Versions
                                                                                                                                                                                                                                                                                        	// (https://docs.aws.amazon.com/glue/latest/dg/release-notes.html#release-notes-versions)
                                                                                                                                                                                                                                                                                        	// in the developer guide.
                                                                                                                                                                                                                                                                                        	GlueVersion *string
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// A list of AWS Glue table definitions used by the transform.
                                                                                                                                                                                                                                                                                        	InputRecordTables []GlueTable
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// A count identifier for the labeling files generated by AWS Glue for this
                                                                                                                                                                                                                                                                                        	// transform. As you create a better transform, you can iteratively download,
                                                                                                                                                                                                                                                                                        	// label, and upload the labeling file.
                                                                                                                                                                                                                                                                                        	LabelCount int32
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// A timestamp. The last point in time when this machine learning transform was
                                                                                                                                                                                                                                                                                        	// modified.
                                                                                                                                                                                                                                                                                        	LastModifiedOn *time.Time
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The number of AWS Glue data processing units (DPUs) that are allocated to task
                                                                                                                                                                                                                                                                                        	// runs for this transform. You can allocate from 2 to 100 DPUs; the default is 10.
                                                                                                                                                                                                                                                                                        	// A DPU is a relative measure of processing power that consists of 4 vCPUs of
                                                                                                                                                                                                                                                                                        	// compute capacity and 16 GB of memory. For more information, see the AWS Glue
                                                                                                                                                                                                                                                                                        	// pricing page (http://aws.amazon.com/glue/pricing/). MaxCapacity is a mutually
                                                                                                                                                                                                                                                                                        	// exclusive option with NumberOfWorkers and WorkerType.
                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                        	// * If either
                                                                                                                                                                                                                                                                                        	// NumberOfWorkers or WorkerType is set, then MaxCapacity cannot be set.
                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                        	// * If
                                                                                                                                                                                                                                                                                        	// MaxCapacity is set then neither NumberOfWorkers or WorkerType can be set.
                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                        	// * If
                                                                                                                                                                                                                                                                                        	// WorkerType is set, then NumberOfWorkers is required (and vice versa).
                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                        	// *
                                                                                                                                                                                                                                                                                        	// MaxCapacity and NumberOfWorkers must both be at least 1.
                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                        	// When the WorkerType
                                                                                                                                                                                                                                                                                        	// field is set to a value other than Standard, the MaxCapacity field is set
                                                                                                                                                                                                                                                                                        	// automatically and becomes read-only.
                                                                                                                                                                                                                                                                                        	MaxCapacity *float64
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The maximum number of times to retry after an MLTaskRun of the machine learning
                                                                                                                                                                                                                                                                                        	// transform fails.
                                                                                                                                                                                                                                                                                        	MaxRetries *int32
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// A user-defined name for the machine learning transform. Names are not guaranteed
                                                                                                                                                                                                                                                                                        	// unique and can be changed at any time.
                                                                                                                                                                                                                                                                                        	Name *string
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The number of workers of a defined workerType that are allocated when a task of
                                                                                                                                                                                                                                                                                        	// the transform runs. If WorkerType is set, then NumberOfWorkers is required (and
                                                                                                                                                                                                                                                                                        	// vice versa).
                                                                                                                                                                                                                                                                                        	NumberOfWorkers *int32
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// A TransformParameters object. You can use parameters to tune (customize) the
                                                                                                                                                                                                                                                                                        	// behavior of the machine learning transform by specifying what data it learns
                                                                                                                                                                                                                                                                                        	// from and your preference on various tradeoffs (such as precious vs. recall, or
                                                                                                                                                                                                                                                                                        	// accuracy vs. cost).
                                                                                                                                                                                                                                                                                        	Parameters *TransformParameters
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The name or Amazon Resource Name (ARN) of the IAM role with the required
                                                                                                                                                                                                                                                                                        	// permissions. The required permissions include both AWS Glue service role
                                                                                                                                                                                                                                                                                        	// permissions to AWS Glue resources, and Amazon S3 permissions required by the
                                                                                                                                                                                                                                                                                        	// transform.
                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                        	// * This role needs AWS Glue service role permissions to allow access
                                                                                                                                                                                                                                                                                        	// to resources in AWS Glue. See Attach a Policy to IAM Users That Access AWS Glue
                                                                                                                                                                                                                                                                                        	// (https://docs.aws.amazon.com/glue/latest/dg/attach-policy-iam-user.html).
                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                        	// *
                                                                                                                                                                                                                                                                                        	// This role needs permission to your Amazon Simple Storage Service (Amazon S3)
                                                                                                                                                                                                                                                                                        	// sources, targets, temporary directory, scripts, and any libraries used by the
                                                                                                                                                                                                                                                                                        	// task run for this transform.
                                                                                                                                                                                                                                                                                        	Role *string
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// A map of key-value pairs representing the columns and data types that this
                                                                                                                                                                                                                                                                                        	// transform can run against. Has an upper bound of 100 columns.
                                                                                                                                                                                                                                                                                        	Schema []SchemaColumn
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The current status of the machine learning transform.
                                                                                                                                                                                                                                                                                        	Status TransformStatusType
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The timeout in minutes of the machine learning transform.
                                                                                                                                                                                                                                                                                        	Timeout *int32
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The encryption-at-rest settings of the transform that apply to accessing user
                                                                                                                                                                                                                                                                                        	// data. Machine learning transforms can access user data encrypted in Amazon S3
                                                                                                                                                                                                                                                                                        	// using KMS.
                                                                                                                                                                                                                                                                                        	TransformEncryption *TransformEncryption
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The unique transform ID that is generated for the machine learning transform.
                                                                                                                                                                                                                                                                                        	// The ID is guaranteed to be unique and does not change.
                                                                                                                                                                                                                                                                                        	TransformId *string
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The type of predefined worker that is allocated when a task of this transform
                                                                                                                                                                                                                                                                                        	// runs. Accepts a value of Standard, G.1X, or G.2X.
                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                        	// * For the Standard worker
                                                                                                                                                                                                                                                                                        	// type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2
                                                                                                                                                                                                                                                                                        	// executors per worker.
                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                        	// * For the G.1X worker type, each worker provides 4 vCPU,
                                                                                                                                                                                                                                                                                        	// 16 GB of memory and a 64GB disk, and 1 executor per worker.
                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                        	// * For the G.2X
                                                                                                                                                                                                                                                                                        	// worker type, each worker provides 8 vCPU, 32 GB of memory and a 128GB disk, and
                                                                                                                                                                                                                                                                                        	// 1 executor per worker.
                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                        	// MaxCapacity is a mutually exclusive option with
                                                                                                                                                                                                                                                                                        	// NumberOfWorkers and WorkerType.
                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                        	// * If either NumberOfWorkers or WorkerType is
                                                                                                                                                                                                                                                                                        	// set, then MaxCapacity cannot be set.
                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                        	// * If MaxCapacity is set then neither
                                                                                                                                                                                                                                                                                        	// NumberOfWorkers or WorkerType can be set.
                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                        	// * If WorkerType is set, then
                                                                                                                                                                                                                                                                                        	// NumberOfWorkers is required (and vice versa).
                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                        	// * MaxCapacity and NumberOfWorkers
                                                                                                                                                                                                                                                                                        	// must both be at least 1.
                                                                                                                                                                                                                                                                                        	WorkerType WorkerType
                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                          A structure for a machine learning transform.

                                                                                                                                                                                                                                                                                          type MLTransformNotReadyException

                                                                                                                                                                                                                                                                                          type MLTransformNotReadyException struct {
                                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                            The machine learning transform is not ready to run.

                                                                                                                                                                                                                                                                                            func (*MLTransformNotReadyException) Error

                                                                                                                                                                                                                                                                                            func (*MLTransformNotReadyException) ErrorCode

                                                                                                                                                                                                                                                                                            func (e *MLTransformNotReadyException) ErrorCode() string

                                                                                                                                                                                                                                                                                            func (*MLTransformNotReadyException) ErrorFault

                                                                                                                                                                                                                                                                                            func (*MLTransformNotReadyException) ErrorMessage

                                                                                                                                                                                                                                                                                            func (e *MLTransformNotReadyException) ErrorMessage() string

                                                                                                                                                                                                                                                                                            type MLUserDataEncryption

                                                                                                                                                                                                                                                                                            type MLUserDataEncryption struct {
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// The encryption mode applied to user data. Valid values are:
                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                            	// * DISABLED:
                                                                                                                                                                                                                                                                                            	// encryption is disabled
                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                            	// * SSEKMS: use of server-side encryption with AWS Key
                                                                                                                                                                                                                                                                                            	// Management Service (SSE-KMS) for user data stored in Amazon S3.
                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                            	MlUserDataEncryptionMode MLUserDataEncryptionModeString
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// The ID for the customer-provided KMS key.
                                                                                                                                                                                                                                                                                            	KmsKeyId *string
                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                              The encryption-at-rest settings of the transform that apply to accessing user data.

                                                                                                                                                                                                                                                                                              type MLUserDataEncryptionModeString

                                                                                                                                                                                                                                                                                              type MLUserDataEncryptionModeString string
                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                              	MLUserDataEncryptionModeStringDisabled MLUserDataEncryptionModeString = "DISABLED"
                                                                                                                                                                                                                                                                                              	MLUserDataEncryptionModeStringSsekms   MLUserDataEncryptionModeString = "SSE-KMS"
                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                Enum values for MLUserDataEncryptionModeString

                                                                                                                                                                                                                                                                                                func (MLUserDataEncryptionModeString) Values

                                                                                                                                                                                                                                                                                                  Values returns all known values for MLUserDataEncryptionModeString. 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 MappingEntry

                                                                                                                                                                                                                                                                                                  type MappingEntry struct {
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// The source path.
                                                                                                                                                                                                                                                                                                  	SourcePath *string
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// The name of the source table.
                                                                                                                                                                                                                                                                                                  	SourceTable *string
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// The source type.
                                                                                                                                                                                                                                                                                                  	SourceType *string
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// The target path.
                                                                                                                                                                                                                                                                                                  	TargetPath *string
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// The target table.
                                                                                                                                                                                                                                                                                                  	TargetTable *string
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// The target type.
                                                                                                                                                                                                                                                                                                  	TargetType *string
                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                    Defines a mapping.

                                                                                                                                                                                                                                                                                                    type MetadataInfo

                                                                                                                                                                                                                                                                                                    type MetadataInfo struct {
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The time at which the entry was created.
                                                                                                                                                                                                                                                                                                    	CreatedTime *string
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The metadata key’s corresponding value.
                                                                                                                                                                                                                                                                                                    	MetadataValue *string
                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                      A structure containing metadata information for a schema version.

                                                                                                                                                                                                                                                                                                      type MetadataKeyValuePair

                                                                                                                                                                                                                                                                                                      type MetadataKeyValuePair struct {
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// A metadata key.
                                                                                                                                                                                                                                                                                                      	MetadataKey *string
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// A metadata key’s corresponding value.
                                                                                                                                                                                                                                                                                                      	MetadataValue *string
                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                        A structure containing a key value pair for metadata.

                                                                                                                                                                                                                                                                                                        type MongoDBTarget

                                                                                                                                                                                                                                                                                                        type MongoDBTarget struct {
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// The name of the connection to use to connect to the Amazon DocumentDB or MongoDB
                                                                                                                                                                                                                                                                                                        	// target.
                                                                                                                                                                                                                                                                                                        	ConnectionName *string
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// The path of the Amazon DocumentDB or MongoDB target (database/collection).
                                                                                                                                                                                                                                                                                                        	Path *string
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// Indicates whether to scan all the records, or to sample rows from the table.
                                                                                                                                                                                                                                                                                                        	// Scanning all the records can take a long time when the table is not a high
                                                                                                                                                                                                                                                                                                        	// throughput table. A value of true means to scan all records, while a value of
                                                                                                                                                                                                                                                                                                        	// false means to sample the records. If no value is specified, the value defaults
                                                                                                                                                                                                                                                                                                        	// to true.
                                                                                                                                                                                                                                                                                                        	ScanAll *bool
                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                          Specifies an Amazon DocumentDB or MongoDB data store to crawl.

                                                                                                                                                                                                                                                                                                          type NoScheduleException

                                                                                                                                                                                                                                                                                                          type NoScheduleException struct {
                                                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                            There is no applicable schedule.

                                                                                                                                                                                                                                                                                                            func (*NoScheduleException) Error

                                                                                                                                                                                                                                                                                                            func (e *NoScheduleException) Error() string

                                                                                                                                                                                                                                                                                                            func (*NoScheduleException) ErrorCode

                                                                                                                                                                                                                                                                                                            func (e *NoScheduleException) ErrorCode() string

                                                                                                                                                                                                                                                                                                            func (*NoScheduleException) ErrorFault

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

                                                                                                                                                                                                                                                                                                            func (*NoScheduleException) ErrorMessage

                                                                                                                                                                                                                                                                                                            func (e *NoScheduleException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                            type Node

                                                                                                                                                                                                                                                                                                            type Node struct {
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// Details of the crawler when the node represents a crawler.
                                                                                                                                                                                                                                                                                                            	CrawlerDetails *CrawlerNodeDetails
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// Details of the Job when the node represents a Job.
                                                                                                                                                                                                                                                                                                            	JobDetails *JobNodeDetails
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The name of the AWS Glue component represented by the node.
                                                                                                                                                                                                                                                                                                            	Name *string
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// Details of the Trigger when the node represents a Trigger.
                                                                                                                                                                                                                                                                                                            	TriggerDetails *TriggerNodeDetails
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The type of AWS Glue component represented by the node.
                                                                                                                                                                                                                                                                                                            	Type NodeType
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The unique Id assigned to the node within the workflow.
                                                                                                                                                                                                                                                                                                            	UniqueId *string
                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                              A node represents an AWS Glue component such as a trigger, or job, etc., that is part of a workflow.

                                                                                                                                                                                                                                                                                                              type NodeType

                                                                                                                                                                                                                                                                                                              type NodeType string
                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                              	NodeTypeCrawler NodeType = "CRAWLER"
                                                                                                                                                                                                                                                                                                              	NodeTypeJob     NodeType = "JOB"
                                                                                                                                                                                                                                                                                                              	NodeTypeTrigger NodeType = "TRIGGER"
                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                Enum values for NodeType

                                                                                                                                                                                                                                                                                                                func (NodeType) Values

                                                                                                                                                                                                                                                                                                                func (NodeType) Values() []NodeType

                                                                                                                                                                                                                                                                                                                  Values returns all known values for NodeType. 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 NotificationProperty

                                                                                                                                                                                                                                                                                                                  type NotificationProperty struct {
                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                  	// After a job run starts, the number of minutes to wait before sending a job run
                                                                                                                                                                                                                                                                                                                  	// delay notification.
                                                                                                                                                                                                                                                                                                                  	NotifyDelayAfter *int32
                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                    Specifies configuration properties of a notification.

                                                                                                                                                                                                                                                                                                                    type OperationTimeoutException

                                                                                                                                                                                                                                                                                                                    type OperationTimeoutException struct {
                                                                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                      The operation timed out.

                                                                                                                                                                                                                                                                                                                      func (*OperationTimeoutException) Error

                                                                                                                                                                                                                                                                                                                      func (e *OperationTimeoutException) Error() string

                                                                                                                                                                                                                                                                                                                      func (*OperationTimeoutException) ErrorCode

                                                                                                                                                                                                                                                                                                                      func (e *OperationTimeoutException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                      func (*OperationTimeoutException) ErrorFault

                                                                                                                                                                                                                                                                                                                      func (*OperationTimeoutException) ErrorMessage

                                                                                                                                                                                                                                                                                                                      func (e *OperationTimeoutException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                      type Order

                                                                                                                                                                                                                                                                                                                      type Order struct {
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The name of the column.
                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                      	Column *string
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// Indicates that the column is sorted in ascending order (== 1), or in descending
                                                                                                                                                                                                                                                                                                                      	// order (==0).
                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                      	SortOrder int32
                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                        Specifies the sort order of a sorted column.

                                                                                                                                                                                                                                                                                                                        type Partition

                                                                                                                                                                                                                                                                                                                        type Partition struct {
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The ID of the Data Catalog in which the partition resides.
                                                                                                                                                                                                                                                                                                                        	CatalogId *string
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The time at which the partition was created.
                                                                                                                                                                                                                                                                                                                        	CreationTime *time.Time
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The name of the catalog database in which to create the partition.
                                                                                                                                                                                                                                                                                                                        	DatabaseName *string
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The last time at which the partition was accessed.
                                                                                                                                                                                                                                                                                                                        	LastAccessTime *time.Time
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The last time at which column statistics were computed for this partition.
                                                                                                                                                                                                                                                                                                                        	LastAnalyzedTime *time.Time
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// These key-value pairs define partition parameters.
                                                                                                                                                                                                                                                                                                                        	Parameters map[string]string
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// Provides information about the physical location where the partition is stored.
                                                                                                                                                                                                                                                                                                                        	StorageDescriptor *StorageDescriptor
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The name of the database table in which to create the partition.
                                                                                                                                                                                                                                                                                                                        	TableName *string
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The values of the partition.
                                                                                                                                                                                                                                                                                                                        	Values []string
                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                          Represents a slice of table data.

                                                                                                                                                                                                                                                                                                                          type PartitionError

                                                                                                                                                                                                                                                                                                                          type PartitionError struct {
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          	// The details about the partition error.
                                                                                                                                                                                                                                                                                                                          	ErrorDetail *ErrorDetail
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          	// The values that define the partition.
                                                                                                                                                                                                                                                                                                                          	PartitionValues []string
                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                            Contains information about a partition error.

                                                                                                                                                                                                                                                                                                                            type PartitionIndex

                                                                                                                                                                                                                                                                                                                            type PartitionIndex struct {
                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                            	// The name of the partition index.
                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                            	IndexName *string
                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                            	// The keys for the partition index.
                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                            	Keys []string
                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                              A structure for a partition index.

                                                                                                                                                                                                                                                                                                                              type PartitionIndexDescriptor

                                                                                                                                                                                                                                                                                                                              type PartitionIndexDescriptor struct {
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// The name of the partition index.
                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                              	IndexName *string
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// The status of the partition index. The possible statuses are:
                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                              	// * CREATING: The
                                                                                                                                                                                                                                                                                                                              	// index is being created. When an index is in a CREATING state, the index or its
                                                                                                                                                                                                                                                                                                                              	// table cannot be deleted.
                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                              	// * ACTIVE: The index creation succeeds.
                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                              	// * FAILED: The
                                                                                                                                                                                                                                                                                                                              	// index creation fails.
                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                              	// * DELETING: The index is deleted from the list of
                                                                                                                                                                                                                                                                                                                              	// indexes.
                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                              	IndexStatus PartitionIndexStatus
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// A list of one or more keys, as KeySchemaElement structures, for the partition
                                                                                                                                                                                                                                                                                                                              	// index.
                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                              	Keys []KeySchemaElement
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// A list of errors that can occur when registering partition indexes for an
                                                                                                                                                                                                                                                                                                                              	// existing table.
                                                                                                                                                                                                                                                                                                                              	BackfillErrors []BackfillError
                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                A descriptor for a partition index in a table.

                                                                                                                                                                                                                                                                                                                                type PartitionIndexStatus

                                                                                                                                                                                                                                                                                                                                type PartitionIndexStatus string
                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                	PartitionIndexStatusCreating PartitionIndexStatus = "CREATING"
                                                                                                                                                                                                                                                                                                                                	PartitionIndexStatusActive   PartitionIndexStatus = "ACTIVE"
                                                                                                                                                                                                                                                                                                                                	PartitionIndexStatusDeleting PartitionIndexStatus = "DELETING"
                                                                                                                                                                                                                                                                                                                                	PartitionIndexStatusFailed   PartitionIndexStatus = "FAILED"
                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                  Enum values for PartitionIndexStatus

                                                                                                                                                                                                                                                                                                                                  func (PartitionIndexStatus) Values

                                                                                                                                                                                                                                                                                                                                    Values returns all known values for PartitionIndexStatus. 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 PartitionInput

                                                                                                                                                                                                                                                                                                                                    type PartitionInput struct {
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// The last time at which the partition was accessed.
                                                                                                                                                                                                                                                                                                                                    	LastAccessTime *time.Time
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// The last time at which column statistics were computed for this partition.
                                                                                                                                                                                                                                                                                                                                    	LastAnalyzedTime *time.Time
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// These key-value pairs define partition parameters.
                                                                                                                                                                                                                                                                                                                                    	Parameters map[string]string
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// Provides information about the physical location where the partition is stored.
                                                                                                                                                                                                                                                                                                                                    	StorageDescriptor *StorageDescriptor
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// The values of the partition. Although this parameter is not required by the SDK,
                                                                                                                                                                                                                                                                                                                                    	// you must specify this parameter for a valid input. The values for the keys for
                                                                                                                                                                                                                                                                                                                                    	// the new partition must be passed as an array of String objects that must be
                                                                                                                                                                                                                                                                                                                                    	// ordered in the same order as the partition keys appearing in the Amazon S3
                                                                                                                                                                                                                                                                                                                                    	// prefix. Otherwise AWS Glue will add the values to the wrong keys.
                                                                                                                                                                                                                                                                                                                                    	Values []string
                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                      The structure used to create and update a partition.

                                                                                                                                                                                                                                                                                                                                      type PartitionValueList

                                                                                                                                                                                                                                                                                                                                      type PartitionValueList struct {
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// The list of values.
                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                      	Values []string
                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                        Contains a list of values defining partitions.

                                                                                                                                                                                                                                                                                                                                        type Permission

                                                                                                                                                                                                                                                                                                                                        type Permission string
                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                        	PermissionAll                Permission = "ALL"
                                                                                                                                                                                                                                                                                                                                        	PermissionSelect             Permission = "SELECT"
                                                                                                                                                                                                                                                                                                                                        	PermissionAlter              Permission = "ALTER"
                                                                                                                                                                                                                                                                                                                                        	PermissionDrop               Permission = "DROP"
                                                                                                                                                                                                                                                                                                                                        	PermissionDelete             Permission = "DELETE"
                                                                                                                                                                                                                                                                                                                                        	PermissionInsert             Permission = "INSERT"
                                                                                                                                                                                                                                                                                                                                        	PermissionCreateDatabase     Permission = "CREATE_DATABASE"
                                                                                                                                                                                                                                                                                                                                        	PermissionCreateTable        Permission = "CREATE_TABLE"
                                                                                                                                                                                                                                                                                                                                        	PermissionDataLocationAccess Permission = "DATA_LOCATION_ACCESS"
                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                          Enum values for Permission

                                                                                                                                                                                                                                                                                                                                          func (Permission) Values

                                                                                                                                                                                                                                                                                                                                          func (Permission) Values() []Permission

                                                                                                                                                                                                                                                                                                                                            Values returns all known values for Permission. 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 PhysicalConnectionRequirements

                                                                                                                                                                                                                                                                                                                                            type PhysicalConnectionRequirements struct {
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The connection's Availability Zone. This field is redundant because the
                                                                                                                                                                                                                                                                                                                                            	// specified subnet implies the Availability Zone to be used. Currently the field
                                                                                                                                                                                                                                                                                                                                            	// must be populated, but it will be deprecated in the future.
                                                                                                                                                                                                                                                                                                                                            	AvailabilityZone *string
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The security group ID list used by the connection.
                                                                                                                                                                                                                                                                                                                                            	SecurityGroupIdList []string
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The subnet ID used by the connection.
                                                                                                                                                                                                                                                                                                                                            	SubnetId *string
                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                              Specifies the physical requirements for a connection.

                                                                                                                                                                                                                                                                                                                                              type Predecessor

                                                                                                                                                                                                                                                                                                                                              type Predecessor struct {
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// The name of the job definition used by the predecessor job run.
                                                                                                                                                                                                                                                                                                                                              	JobName *string
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// The job-run ID of the predecessor job run.
                                                                                                                                                                                                                                                                                                                                              	RunId *string
                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                A job run that was used in the predicate of a conditional trigger that triggered this job run.

                                                                                                                                                                                                                                                                                                                                                type Predicate

                                                                                                                                                                                                                                                                                                                                                type Predicate struct {
                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                	// A list of the conditions that determine when the trigger will fire.
                                                                                                                                                                                                                                                                                                                                                	Conditions []Condition
                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                	// An optional field if only one condition is listed. If multiple conditions are
                                                                                                                                                                                                                                                                                                                                                	// listed, then this field is required.
                                                                                                                                                                                                                                                                                                                                                	Logical Logical
                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                  Defines the predicate of the trigger, which determines when it fires.

                                                                                                                                                                                                                                                                                                                                                  type PrincipalPermissions

                                                                                                                                                                                                                                                                                                                                                  type PrincipalPermissions struct {
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// The permissions that are granted to the principal.
                                                                                                                                                                                                                                                                                                                                                  	Permissions []Permission
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// The principal who is granted permissions.
                                                                                                                                                                                                                                                                                                                                                  	Principal *DataLakePrincipal
                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                    Permissions granted to a principal.

                                                                                                                                                                                                                                                                                                                                                    type PrincipalType

                                                                                                                                                                                                                                                                                                                                                    type PrincipalType string
                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                    	PrincipalTypeUser  PrincipalType = "USER"
                                                                                                                                                                                                                                                                                                                                                    	PrincipalTypeRole  PrincipalType = "ROLE"
                                                                                                                                                                                                                                                                                                                                                    	PrincipalTypeGroup PrincipalType = "GROUP"
                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                      Enum values for PrincipalType

                                                                                                                                                                                                                                                                                                                                                      func (PrincipalType) Values

                                                                                                                                                                                                                                                                                                                                                      func (PrincipalType) Values() []PrincipalType

                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for PrincipalType. 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 PropertyPredicate

                                                                                                                                                                                                                                                                                                                                                        type PropertyPredicate struct {
                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                        	// The comparator used to compare this property to others.
                                                                                                                                                                                                                                                                                                                                                        	Comparator Comparator
                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                        	// The key of the property.
                                                                                                                                                                                                                                                                                                                                                        	Key *string
                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                        	// The value of the property.
                                                                                                                                                                                                                                                                                                                                                        	Value *string
                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                          Defines a property predicate.

                                                                                                                                                                                                                                                                                                                                                          type RecrawlBehavior

                                                                                                                                                                                                                                                                                                                                                          type RecrawlBehavior string
                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                          	RecrawlBehaviorCrawlEverything     RecrawlBehavior = "CRAWL_EVERYTHING"
                                                                                                                                                                                                                                                                                                                                                          	RecrawlBehaviorCrawlNewFoldersOnly RecrawlBehavior = "CRAWL_NEW_FOLDERS_ONLY"
                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                            Enum values for RecrawlBehavior

                                                                                                                                                                                                                                                                                                                                                            func (RecrawlBehavior) Values

                                                                                                                                                                                                                                                                                                                                                            func (RecrawlBehavior) Values() []RecrawlBehavior

                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for RecrawlBehavior. 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 RecrawlPolicy

                                                                                                                                                                                                                                                                                                                                                              type RecrawlPolicy struct {
                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                              	// Specifies whether to crawl the entire dataset again or to crawl only folders
                                                                                                                                                                                                                                                                                                                                                              	// that were added since the last crawler run. A value of CRAWL_EVERYTHING
                                                                                                                                                                                                                                                                                                                                                              	// specifies crawling the entire dataset again. A value of CRAWL_NEW_FOLDERS_ONLY
                                                                                                                                                                                                                                                                                                                                                              	// specifies crawling only folders that were added since the last crawler run.
                                                                                                                                                                                                                                                                                                                                                              	RecrawlBehavior RecrawlBehavior
                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                When crawling an Amazon S3 data source after the first crawl is complete, specifies whether to crawl the entire dataset again or to crawl only folders that were added since the last crawler run. For more information, see Incremental Crawls in AWS Glue (https://docs.aws.amazon.com/glue/latest/dg/incremental-crawls.html) in the developer guide.

                                                                                                                                                                                                                                                                                                                                                                type RegistryId

                                                                                                                                                                                                                                                                                                                                                                type RegistryId struct {
                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                	// Arn of the registry to be updated. One of RegistryArn or RegistryName has to be
                                                                                                                                                                                                                                                                                                                                                                	// provided.
                                                                                                                                                                                                                                                                                                                                                                	RegistryArn *string
                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                	// Name of the registry. Used only for lookup. One of RegistryArn or RegistryName
                                                                                                                                                                                                                                                                                                                                                                	// has to be provided.
                                                                                                                                                                                                                                                                                                                                                                	RegistryName *string
                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                  A wrapper structure that may contain the registry name and Amazon Resource Name (ARN).

                                                                                                                                                                                                                                                                                                                                                                  type RegistryListItem

                                                                                                                                                                                                                                                                                                                                                                  type RegistryListItem struct {
                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                  	// The data the registry was created.
                                                                                                                                                                                                                                                                                                                                                                  	CreatedTime *string
                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                  	// A description of the registry.
                                                                                                                                                                                                                                                                                                                                                                  	Description *string
                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) of the registry.
                                                                                                                                                                                                                                                                                                                                                                  	RegistryArn *string
                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                  	// The name of the registry.
                                                                                                                                                                                                                                                                                                                                                                  	RegistryName *string
                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                  	// The status of the registry.
                                                                                                                                                                                                                                                                                                                                                                  	Status RegistryStatus
                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                  	// The date the registry was updated.
                                                                                                                                                                                                                                                                                                                                                                  	UpdatedTime *string
                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                    A structure containing the details for a registry.

                                                                                                                                                                                                                                                                                                                                                                    type RegistryStatus

                                                                                                                                                                                                                                                                                                                                                                    type RegistryStatus string
                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                    	RegistryStatusAvailable RegistryStatus = "AVAILABLE"
                                                                                                                                                                                                                                                                                                                                                                    	RegistryStatusDeleting  RegistryStatus = "DELETING"
                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                      Enum values for RegistryStatus

                                                                                                                                                                                                                                                                                                                                                                      func (RegistryStatus) Values

                                                                                                                                                                                                                                                                                                                                                                      func (RegistryStatus) Values() []RegistryStatus

                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for RegistryStatus. 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 ResourceNumberLimitExceededException

                                                                                                                                                                                                                                                                                                                                                                        type ResourceNumberLimitExceededException struct {
                                                                                                                                                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                          A resource numerical limit was exceeded.

                                                                                                                                                                                                                                                                                                                                                                          func (*ResourceNumberLimitExceededException) Error

                                                                                                                                                                                                                                                                                                                                                                          func (*ResourceNumberLimitExceededException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                          func (*ResourceNumberLimitExceededException) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                          func (*ResourceNumberLimitExceededException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                          func (e *ResourceNumberLimitExceededException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                          type ResourceShareType

                                                                                                                                                                                                                                                                                                                                                                          type ResourceShareType string
                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                          	ResourceShareTypeForeign ResourceShareType = "FOREIGN"
                                                                                                                                                                                                                                                                                                                                                                          	ResourceShareTypeAll     ResourceShareType = "ALL"
                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                            Enum values for ResourceShareType

                                                                                                                                                                                                                                                                                                                                                                            func (ResourceShareType) Values

                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for ResourceShareType. 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 ResourceType

                                                                                                                                                                                                                                                                                                                                                                              type ResourceType string
                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                              	ResourceTypeJar     ResourceType = "JAR"
                                                                                                                                                                                                                                                                                                                                                                              	ResourceTypeFile    ResourceType = "FILE"
                                                                                                                                                                                                                                                                                                                                                                              	ResourceTypeArchive ResourceType = "ARCHIVE"
                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                Enum values for ResourceType

                                                                                                                                                                                                                                                                                                                                                                                func (ResourceType) Values

                                                                                                                                                                                                                                                                                                                                                                                func (ResourceType) Values() []ResourceType

                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for ResourceType. 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 ResourceUri

                                                                                                                                                                                                                                                                                                                                                                                  type ResourceUri struct {
                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                  	// The type of the resource.
                                                                                                                                                                                                                                                                                                                                                                                  	ResourceType ResourceType
                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                  	// The URI for accessing the resource.
                                                                                                                                                                                                                                                                                                                                                                                  	Uri *string
                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                    The URIs for function resources.

                                                                                                                                                                                                                                                                                                                                                                                    type S3Encryption

                                                                                                                                                                                                                                                                                                                                                                                    type S3Encryption struct {
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    	// The Amazon Resource Name (ARN) of the KMS key to be used to encrypt the data.
                                                                                                                                                                                                                                                                                                                                                                                    	KmsKeyArn *string
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    	// The encryption mode to use for Amazon S3 data.
                                                                                                                                                                                                                                                                                                                                                                                    	S3EncryptionMode S3EncryptionMode
                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                      Specifies how Amazon Simple Storage Service (Amazon S3) data should be encrypted.

                                                                                                                                                                                                                                                                                                                                                                                      type S3EncryptionMode

                                                                                                                                                                                                                                                                                                                                                                                      type S3EncryptionMode string
                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                      	S3EncryptionModeDisabled S3EncryptionMode = "DISABLED"
                                                                                                                                                                                                                                                                                                                                                                                      	S3EncryptionModeSsekms   S3EncryptionMode = "SSE-KMS"
                                                                                                                                                                                                                                                                                                                                                                                      	S3EncryptionModeSses3    S3EncryptionMode = "SSE-S3"
                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                        Enum values for S3EncryptionMode

                                                                                                                                                                                                                                                                                                                                                                                        func (S3EncryptionMode) Values

                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for S3EncryptionMode. 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 S3Target

                                                                                                                                                                                                                                                                                                                                                                                          type S3Target struct {
                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                          	// The name of a connection which allows a job or crawler to access data in Amazon
                                                                                                                                                                                                                                                                                                                                                                                          	// S3 within an Amazon Virtual Private Cloud environment (Amazon VPC).
                                                                                                                                                                                                                                                                                                                                                                                          	ConnectionName *string
                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                          	// A list of glob patterns used to exclude from the crawl. For more information,
                                                                                                                                                                                                                                                                                                                                                                                          	// see Catalog Tables with a Crawler
                                                                                                                                                                                                                                                                                                                                                                                          	// (https://docs.aws.amazon.com/glue/latest/dg/add-crawler.html).
                                                                                                                                                                                                                                                                                                                                                                                          	Exclusions []string
                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                          	// The path to the Amazon S3 target.
                                                                                                                                                                                                                                                                                                                                                                                          	Path *string
                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                            Specifies a data store in Amazon Simple Storage Service (Amazon S3).

                                                                                                                                                                                                                                                                                                                                                                                            type Schedule

                                                                                                                                                                                                                                                                                                                                                                                            type Schedule struct {
                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                            	// A cron expression used to specify the schedule (see Time-Based Schedules for
                                                                                                                                                                                                                                                                                                                                                                                            	// Jobs and Crawlers
                                                                                                                                                                                                                                                                                                                                                                                            	// (https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html).
                                                                                                                                                                                                                                                                                                                                                                                            	// For example, to run something every day at 12:15 UTC, you would specify: cron(15
                                                                                                                                                                                                                                                                                                                                                                                            	// 12 * * ? *).
                                                                                                                                                                                                                                                                                                                                                                                            	ScheduleExpression *string
                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                            	// The state of the schedule.
                                                                                                                                                                                                                                                                                                                                                                                            	State ScheduleState
                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                              A scheduling object using a cron statement to schedule an event.

                                                                                                                                                                                                                                                                                                                                                                                              type ScheduleState

                                                                                                                                                                                                                                                                                                                                                                                              type ScheduleState string
                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                              	ScheduleStateScheduled     ScheduleState = "SCHEDULED"
                                                                                                                                                                                                                                                                                                                                                                                              	ScheduleStateNotScheduled  ScheduleState = "NOT_SCHEDULED"
                                                                                                                                                                                                                                                                                                                                                                                              	ScheduleStateTransitioning ScheduleState = "TRANSITIONING"
                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                Enum values for ScheduleState

                                                                                                                                                                                                                                                                                                                                                                                                func (ScheduleState) Values

                                                                                                                                                                                                                                                                                                                                                                                                func (ScheduleState) Values() []ScheduleState

                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for ScheduleState. 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 SchedulerNotRunningException

                                                                                                                                                                                                                                                                                                                                                                                                  type SchedulerNotRunningException struct {
                                                                                                                                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                    The specified scheduler is not running.

                                                                                                                                                                                                                                                                                                                                                                                                    func (*SchedulerNotRunningException) Error

                                                                                                                                                                                                                                                                                                                                                                                                    func (*SchedulerNotRunningException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                    func (e *SchedulerNotRunningException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                    func (*SchedulerNotRunningException) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                    func (*SchedulerNotRunningException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                    func (e *SchedulerNotRunningException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                    type SchedulerRunningException

                                                                                                                                                                                                                                                                                                                                                                                                    type SchedulerRunningException struct {
                                                                                                                                                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                      The specified scheduler is already running.

                                                                                                                                                                                                                                                                                                                                                                                                      func (*SchedulerRunningException) Error

                                                                                                                                                                                                                                                                                                                                                                                                      func (e *SchedulerRunningException) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                      func (*SchedulerRunningException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                      func (e *SchedulerRunningException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                      func (*SchedulerRunningException) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                      func (*SchedulerRunningException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                      func (e *SchedulerRunningException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                      type SchedulerTransitioningException

                                                                                                                                                                                                                                                                                                                                                                                                      type SchedulerTransitioningException struct {
                                                                                                                                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                        The specified scheduler is transitioning.

                                                                                                                                                                                                                                                                                                                                                                                                        func (*SchedulerTransitioningException) Error

                                                                                                                                                                                                                                                                                                                                                                                                        func (*SchedulerTransitioningException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                        func (e *SchedulerTransitioningException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                        func (*SchedulerTransitioningException) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                        func (*SchedulerTransitioningException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                        func (e *SchedulerTransitioningException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                        type SchemaChangePolicy

                                                                                                                                                                                                                                                                                                                                                                                                        type SchemaChangePolicy struct {
                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                        	// The deletion behavior when the crawler finds a deleted object.
                                                                                                                                                                                                                                                                                                                                                                                                        	DeleteBehavior DeleteBehavior
                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                        	// The update behavior when the crawler finds a changed schema.
                                                                                                                                                                                                                                                                                                                                                                                                        	UpdateBehavior UpdateBehavior
                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                          A policy that specifies update and deletion behaviors for the crawler.

                                                                                                                                                                                                                                                                                                                                                                                                          type SchemaColumn

                                                                                                                                                                                                                                                                                                                                                                                                          type SchemaColumn struct {
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// The type of data in the column.
                                                                                                                                                                                                                                                                                                                                                                                                          	DataType *string
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// The name of the column.
                                                                                                                                                                                                                                                                                                                                                                                                          	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                            A key-value pair representing a column and data type that this transform can run against. The Schema parameter of the MLTransform may contain up to 100 of these structures.

                                                                                                                                                                                                                                                                                                                                                                                                            type SchemaDiffType

                                                                                                                                                                                                                                                                                                                                                                                                            type SchemaDiffType string
                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                            	SchemaDiffTypeSyntaxDiff SchemaDiffType = "SYNTAX_DIFF"
                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                              Enum values for SchemaDiffType

                                                                                                                                                                                                                                                                                                                                                                                                              func (SchemaDiffType) Values

                                                                                                                                                                                                                                                                                                                                                                                                              func (SchemaDiffType) Values() []SchemaDiffType

                                                                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for SchemaDiffType. 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 SchemaId

                                                                                                                                                                                                                                                                                                                                                                                                                type SchemaId struct {
                                                                                                                                                                                                                                                                                                                                                                                                                	RegistryName *string
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                	SchemaArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                	SchemaName *string
                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                type SchemaListItem

                                                                                                                                                                                                                                                                                                                                                                                                                type SchemaListItem struct {
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                	// The date and time that a schema was created.
                                                                                                                                                                                                                                                                                                                                                                                                                	CreatedTime *string
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                	// A description for the schema.
                                                                                                                                                                                                                                                                                                                                                                                                                	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                	// the name of the registry where the schema resides.
                                                                                                                                                                                                                                                                                                                                                                                                                	RegistryName *string
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                	// The Amazon Resource Name (ARN) for the schema.
                                                                                                                                                                                                                                                                                                                                                                                                                	SchemaArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                	// The name of the schema.
                                                                                                                                                                                                                                                                                                                                                                                                                	SchemaName *string
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                	// The status of the schema.
                                                                                                                                                                                                                                                                                                                                                                                                                	SchemaStatus SchemaStatus
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                	// The date and time that a schema was updated.
                                                                                                                                                                                                                                                                                                                                                                                                                	UpdatedTime *string
                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                  An object that contains minimal details for a schema.

                                                                                                                                                                                                                                                                                                                                                                                                                  type SchemaReference

                                                                                                                                                                                                                                                                                                                                                                                                                  type SchemaReference struct {
                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                  	// A structure that contains schema identity fields. Either this or the
                                                                                                                                                                                                                                                                                                                                                                                                                  	// SchemaVersionId has to be provided.
                                                                                                                                                                                                                                                                                                                                                                                                                  	SchemaId *SchemaId
                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                  	// The unique ID assigned to a version of the schema. Either this or the SchemaId
                                                                                                                                                                                                                                                                                                                                                                                                                  	// has to be provided.
                                                                                                                                                                                                                                                                                                                                                                                                                  	SchemaVersionId *string
                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                  	// The version number of the schema.
                                                                                                                                                                                                                                                                                                                                                                                                                  	SchemaVersionNumber int64
                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                    An object that references a schema stored in the AWS Glue Schema Registry.

                                                                                                                                                                                                                                                                                                                                                                                                                    type SchemaStatus

                                                                                                                                                                                                                                                                                                                                                                                                                    type SchemaStatus string
                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                    	SchemaStatusAvailable SchemaStatus = "AVAILABLE"
                                                                                                                                                                                                                                                                                                                                                                                                                    	SchemaStatusPending   SchemaStatus = "PENDING"
                                                                                                                                                                                                                                                                                                                                                                                                                    	SchemaStatusDeleting  SchemaStatus = "DELETING"
                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                      Enum values for SchemaStatus

                                                                                                                                                                                                                                                                                                                                                                                                                      func (SchemaStatus) Values

                                                                                                                                                                                                                                                                                                                                                                                                                      func (SchemaStatus) Values() []SchemaStatus

                                                                                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for SchemaStatus. 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 SchemaVersionErrorItem

                                                                                                                                                                                                                                                                                                                                                                                                                        type SchemaVersionErrorItem struct {
                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                        	// The details of the error for the schema version.
                                                                                                                                                                                                                                                                                                                                                                                                                        	ErrorDetails *ErrorDetails
                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                        	// The version number of the schema.
                                                                                                                                                                                                                                                                                                                                                                                                                        	VersionNumber int64
                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                          An object that contains the error details for an operation on a schema version.

                                                                                                                                                                                                                                                                                                                                                                                                                          type SchemaVersionListItem

                                                                                                                                                                                                                                                                                                                                                                                                                          type SchemaVersionListItem struct {
                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                          	// The date and time the schema version was created.
                                                                                                                                                                                                                                                                                                                                                                                                                          	CreatedTime *string
                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                          	// The Amazon Resource Name (ARN) of the schema.
                                                                                                                                                                                                                                                                                                                                                                                                                          	SchemaArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                          	// The unique identifier of the schema version.
                                                                                                                                                                                                                                                                                                                                                                                                                          	SchemaVersionId *string
                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                          	// The status of the schema version.
                                                                                                                                                                                                                                                                                                                                                                                                                          	Status SchemaVersionStatus
                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                          	// The version number of the schema.
                                                                                                                                                                                                                                                                                                                                                                                                                          	VersionNumber int64
                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                            An object containing the details about a schema version.

                                                                                                                                                                                                                                                                                                                                                                                                                            type SchemaVersionNumber

                                                                                                                                                                                                                                                                                                                                                                                                                            type SchemaVersionNumber struct {
                                                                                                                                                                                                                                                                                                                                                                                                                            	LatestVersion bool
                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                            	VersionNumber int64
                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                            type SchemaVersionStatus

                                                                                                                                                                                                                                                                                                                                                                                                                            type SchemaVersionStatus string
                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                            	SchemaVersionStatusAvailable SchemaVersionStatus = "AVAILABLE"
                                                                                                                                                                                                                                                                                                                                                                                                                            	SchemaVersionStatusPending   SchemaVersionStatus = "PENDING"
                                                                                                                                                                                                                                                                                                                                                                                                                            	SchemaVersionStatusFailure   SchemaVersionStatus = "FAILURE"
                                                                                                                                                                                                                                                                                                                                                                                                                            	SchemaVersionStatusDeleting  SchemaVersionStatus = "DELETING"
                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                              Enum values for SchemaVersionStatus

                                                                                                                                                                                                                                                                                                                                                                                                                              func (SchemaVersionStatus) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for SchemaVersionStatus. 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 SecurityConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                type SecurityConfiguration struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                	// The time at which this security configuration was created.
                                                                                                                                                                                                                                                                                                                                                                                                                                	CreatedTimeStamp *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                	// The encryption configuration associated with this security configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                	EncryptionConfiguration *EncryptionConfiguration
                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                	// The name of the security configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                  Specifies a security configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                  type Segment

                                                                                                                                                                                                                                                                                                                                                                                                                                  type Segment struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The zero-based index number of the segment. For example, if the total number of
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// segments is 4, SegmentNumber values range from 0 through 3.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	SegmentNumber int32
                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The total number of segments.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	TotalSegments int32
                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                    Defines a non-overlapping region of a table's partitions, allowing multiple requests to be executed in parallel.

                                                                                                                                                                                                                                                                                                                                                                                                                                    type SerDeInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                    type SerDeInfo struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Name of the SerDe.
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                    	// These key-value pairs define initialization parameters for the SerDe.
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Parameters map[string]string
                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Usually the class that implements the SerDe. An example is
                                                                                                                                                                                                                                                                                                                                                                                                                                    	// org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe.
                                                                                                                                                                                                                                                                                                                                                                                                                                    	SerializationLibrary *string
                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                      Information about a serialization/deserialization program (SerDe) that serves as an extractor and loader.

                                                                                                                                                                                                                                                                                                                                                                                                                                      type SkewedInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                      type SkewedInfo struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// A list of names of columns that contain skewed values.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	SkewedColumnNames []string
                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// A mapping of skewed values to the columns that contain them.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	SkewedColumnValueLocationMaps map[string]string
                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                      	// A list of values that appear so frequently as to be considered skewed.
                                                                                                                                                                                                                                                                                                                                                                                                                                      	SkewedColumnValues []string
                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                        Specifies skewed values in a table. Skewed values are those that occur with very high frequency.

                                                                                                                                                                                                                                                                                                                                                                                                                                        type Sort

                                                                                                                                                                                                                                                                                                                                                                                                                                        type Sort string
                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                        	SortAscending  Sort = "ASC"
                                                                                                                                                                                                                                                                                                                                                                                                                                        	SortDescending Sort = "DESC"
                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for Sort

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (Sort) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (Sort) Values() []Sort

                                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for Sort. 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 SortCriterion

                                                                                                                                                                                                                                                                                                                                                                                                                                            type SortCriterion struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The name of the field on which to sort.
                                                                                                                                                                                                                                                                                                                                                                                                                                            	FieldName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                            	// An ascending or descending sort.
                                                                                                                                                                                                                                                                                                                                                                                                                                            	Sort Sort
                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                              Specifies a field to sort by and a sort order.

                                                                                                                                                                                                                                                                                                                                                                                                                                              type SortDirectionType

                                                                                                                                                                                                                                                                                                                                                                                                                                              type SortDirectionType string
                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                              	SortDirectionTypeDescending SortDirectionType = "DESCENDING"
                                                                                                                                                                                                                                                                                                                                                                                                                                              	SortDirectionTypeAscending  SortDirectionType = "ASCENDING"
                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum values for SortDirectionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (SortDirectionType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for SortDirectionType. 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 StorageDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type StorageDescriptor struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// A list of reducer grouping columns, clustering columns, and bucketing columns in
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// the table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	BucketColumns []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// A list of the Columns in the table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Columns []Column
                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// True if the data in the table is compressed, or False if not.
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Compressed bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The input format: SequenceFileInputFormat (binary), or TextInputFormat, or a
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// custom format.
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	InputFormat *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The physical location of the table. By default, this takes the form of the
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// warehouse location, followed by the database location in the warehouse, followed
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// by the table name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Location *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Must be specified if the table contains any dimension columns.
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	NumberOfBuckets int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The output format: SequenceFileOutputFormat (binary), or
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// IgnoreKeyTextOutputFormat, or a custom format.
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	OutputFormat *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The user-supplied properties in key-value form.
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Parameters map[string]string
                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// An object that references a schema stored in the AWS Glue Schema Registry. When
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// creating a table, you can pass an empty list of columns for the schema, and
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// instead use a schema reference.
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	SchemaReference *SchemaReference
                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The serialization/deserialization (SerDe) information.
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	SerdeInfo *SerDeInfo
                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The information about values that appear frequently in a column (skewed values).
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	SkewedInfo *SkewedInfo
                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// A list specifying the sort order of each bucket in the table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	SortColumns []Order
                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// True if the table data is stored in subdirectories, or False if not.
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	StoredAsSubDirectories bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Describes the physical storage of table data.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type StringColumnStatisticsData

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type StringColumnStatisticsData struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The average string length in the column.
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	AverageLength float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The size of the longest string in the column.
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	MaximumLength int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The number of distinct values in a column.
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	NumberOfDistinctValues int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The number of null values in the column.
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	NumberOfNulls int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Defines column statistics supported for character sequence data values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Table struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The table name. For Hive compatibility, this must be entirely lowercase.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The ID of the Data Catalog in which the table resides.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	CatalogId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The time when the table definition was created in the Data Catalog.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	CreateTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The person or entity who created the table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	CreatedBy *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The name of the database where the table metadata resides. For Hive
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// compatibility, this must be all lowercase.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DatabaseName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// A description of the table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Indicates whether the table has been registered with AWS Lake Formation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	IsRegisteredWithLakeFormation bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The last time that the table was accessed. This is usually taken from HDFS, and
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// might not be reliable.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	LastAccessTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The last time that column statistics were computed for this table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	LastAnalyzedTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The owner of the table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Owner *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// These key-value pairs define properties associated with the table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Parameters map[string]string
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// A list of columns by which the table is partitioned. Only primitive types are
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// supported as partition keys. When you create a table used by Amazon Athena, and
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// you do not specify any partitionKeys, you must at least set the value of
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// partitionKeys to an empty list. For example: "PartitionKeys": []
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	PartitionKeys []Column
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The retention time for this table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Retention int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// A storage descriptor containing information about the physical storage of this
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	StorageDescriptor *StorageDescriptor
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The type of this table (EXTERNAL_TABLE, VIRTUAL_VIEW, etc.).
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	TableType *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// A TableIdentifier structure that describes a target table for resource linking.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	TargetTable *TableIdentifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The last time that the table was updated.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	UpdateTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// If the table is a view, the expanded text of the view; otherwise null.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ViewExpandedText *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// If the table is a view, the original text of the view; otherwise null.
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ViewOriginalText *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Represents a collection of related data organized in columns and rows.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TableError

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TableError struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The details about the error.
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ErrorDetail *ErrorDetail
                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The name of the table. For Hive compatibility, this must be entirely lowercase.
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TableName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                          An error record for table operations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TableIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TableIdentifier struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The ID of the Data Catalog in which the table resides.
                                                                                                                                                                                                                                                                                                                                                                                                                                                          	CatalogId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The name of the catalog database that contains the target table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                          	DatabaseName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The name of the target table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                            A structure that describes a target table for resource linking.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TableInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TableInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The table name. For Hive compatibility, this is folded to lowercase when it is
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// stored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// A description of the table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The last time that the table was accessed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	LastAccessTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The last time that column statistics were computed for this table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	LastAnalyzedTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The table owner.
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Owner *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// These key-value pairs define properties associated with the table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Parameters map[string]string
                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// A list of columns by which the table is partitioned. Only primitive types are
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// supported as partition keys. When you create a table used by Amazon Athena, and
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// you do not specify any partitionKeys, you must at least set the value of
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// partitionKeys to an empty list. For example: "PartitionKeys": []
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	PartitionKeys []Column
                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The retention time for this table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Retention int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// A storage descriptor containing information about the physical storage of this
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// table.
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	StorageDescriptor *StorageDescriptor
                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The type of this table (EXTERNAL_TABLE, VIRTUAL_VIEW, etc.).
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	TableType *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// A TableIdentifier structure that describes a target table for resource linking.
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	TargetTable *TableIdentifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// If the table is a view, the expanded text of the view; otherwise null.
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ViewExpandedText *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// If the table is a view, the original text of the view; otherwise null.
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ViewOriginalText *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                              A structure used to define a table.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TableVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TableVersion struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The table in question.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Table *Table
                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The ID value that identifies this table version. A VersionId is a string
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// representation of an integer. Each version is incremented by 1.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	VersionId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specifies a version of a table.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TableVersionError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TableVersionError struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The details about the error.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ErrorDetail *ErrorDetail
                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The name of the table in question.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	TableName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The ID value of the version in question. A VersionID is a string representation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// of an integer. Each version is incremented by 1.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	VersionId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An error record for table-version operations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TaskRun

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TaskRun struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The last point in time that the requested task run was completed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	CompletedOn *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The list of error strings associated with this task run.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ErrorString *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The amount of time (in seconds) that the task run consumed resources.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ExecutionTime int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The last point in time that the requested task run was updated.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	LastModifiedOn *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The names of the log group for secure logging, associated with this task run.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	LogGroupName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Specifies configuration properties associated with this task run.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Properties *TaskRunProperties
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The date and time that this task run started.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	StartedOn *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The current status of the requested task run.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Status TaskStatusType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The unique identifier for this task run.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TaskRunId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The unique identifier for the transform.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TransformId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The sampling parameters that are associated with the machine learning transform.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TaskRunFilterCriteria

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TaskRunFilterCriteria struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Filter on task runs started after this date.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	StartedAfter *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Filter on task runs started before this date.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	StartedBefore *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The current status of the task run.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Status TaskStatusType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The type of task run.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	TaskRunType TaskType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The criteria that are used to filter the task runs for the machine learning transform.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TaskRunProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TaskRunProperties struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The configuration properties for an exporting labels task run.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ExportLabelsTaskRunProperties *ExportLabelsTaskRunProperties
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The configuration properties for a find matches task run.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FindMatchesTaskRunProperties *FindMatchesTaskRunProperties
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The configuration properties for an importing labels task run.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ImportLabelsTaskRunProperties *ImportLabelsTaskRunProperties
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The configuration properties for a labeling set generation task run.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	LabelingSetGenerationTaskRunProperties *LabelingSetGenerationTaskRunProperties
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The type of task run.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	TaskType TaskType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The configuration properties for the task run.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TaskRunSortColumnType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TaskRunSortColumnType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TaskRunSortColumnTypeTaskRunType TaskRunSortColumnType = "TASK_RUN_TYPE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TaskRunSortColumnTypeStatus      TaskRunSortColumnType = "STATUS"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TaskRunSortColumnTypeStarted     TaskRunSortColumnType = "STARTED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for TaskRunSortColumnType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (TaskRunSortColumnType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for TaskRunSortColumnType. 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 TaskRunSortCriteria

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TaskRunSortCriteria struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The column to be used to sort the list of task runs for the machine learning
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// transform.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Column TaskRunSortColumnType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The sort direction to be used to sort the list of task runs for the machine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// learning transform.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	SortDirection SortDirectionType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The sorting criteria that are used to sort the list of task runs for the machine learning transform.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TaskStatusType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TaskStatusType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TaskStatusTypeStarting  TaskStatusType = "STARTING"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TaskStatusTypeRunning   TaskStatusType = "RUNNING"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TaskStatusTypeStopping  TaskStatusType = "STOPPING"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TaskStatusTypeStopped   TaskStatusType = "STOPPED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TaskStatusTypeSucceeded TaskStatusType = "SUCCEEDED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TaskStatusTypeFailed    TaskStatusType = "FAILED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TaskStatusTypeTimeout   TaskStatusType = "TIMEOUT"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum values for TaskStatusType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (TaskStatusType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (TaskStatusType) Values() []TaskStatusType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for TaskStatusType. 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 TaskType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TaskType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TaskTypeEvaluation            TaskType = "EVALUATION"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TaskTypeLabelingSetGeneration TaskType = "LABELING_SET_GENERATION"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TaskTypeImportLabels          TaskType = "IMPORT_LABELS"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TaskTypeExportLabels          TaskType = "EXPORT_LABELS"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TaskTypeFindMatches           TaskType = "FIND_MATCHES"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enum values for TaskType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (TaskType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (TaskType) Values() []TaskType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for TaskType. 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 TransformEncryption

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TransformEncryption struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// An MLUserDataEncryption object containing the encryption mode and
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// customer-provided KMS key ID.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	MlUserDataEncryption *MLUserDataEncryption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The name of the security configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	TaskRunSecurityConfigurationName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The encryption-at-rest settings of the transform that apply to accessing user data. Machine learning transforms can access user data encrypted in Amazon S3 using KMS. Additionally, imported labels and trained transforms can now be encrypted using a customer provided KMS key.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TransformFilterCriteria

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TransformFilterCriteria struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The time and date after which the transforms were created.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CreatedAfter *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The time and date before which the transforms were created.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CreatedBefore *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// This value determines which version of AWS Glue this machine learning transform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// is compatible with. Glue 1.0 is recommended for most customers. If the value is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// not set, the Glue compatibility defaults to Glue 0.9. For more information, see
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// AWS Glue Versions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// (https://docs.aws.amazon.com/glue/latest/dg/release-notes.html#release-notes-versions)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// in the developer guide.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	GlueVersion *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Filter on transforms last modified after this date.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	LastModifiedAfter *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Filter on transforms last modified before this date.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	LastModifiedBefore *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// A unique transform name that is used to filter the machine learning transforms.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Filters on datasets with a specific schema. The Map object is an array of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// key-value pairs representing the schema this transform accepts, where Column is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// the name of a column, and Type is the type of the data such as an integer or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// string. Has an upper bound of 100 columns.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Schema []SchemaColumn
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Filters the list of machine learning transforms by the last known status of the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// transforms (to indicate whether a transform can be used or not). One of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// "NOT_READY", "READY", or "DELETING".
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Status TransformStatusType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The type of machine learning transform that is used to filter the machine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// learning transforms.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TransformType TransformType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The criteria used to filter the machine learning transforms.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TransformParameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TransformParameters struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The type of machine learning transform. For information about the types of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// machine learning transforms, see Creating Machine Learning Transforms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// (https://docs.aws.amazon.com/glue/latest/dg/add-job-machine-learning-transform.html).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	TransformType TransformType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The parameters for the find matches algorithm.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	FindMatchesParameters *FindMatchesParameters
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The algorithm-specific parameters that are associated with the machine learning transform.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TransformSortColumnType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TransformSortColumnType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	TransformSortColumnTypeName          TransformSortColumnType = "NAME"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	TransformSortColumnTypeTransformType TransformSortColumnType = "TRANSFORM_TYPE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	TransformSortColumnTypeStatus        TransformSortColumnType = "STATUS"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	TransformSortColumnTypeCreated       TransformSortColumnType = "CREATED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	TransformSortColumnTypeLastModified  TransformSortColumnType = "LAST_MODIFIED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enum values for TransformSortColumnType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (TransformSortColumnType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for TransformSortColumnType. 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 TransformSortCriteria

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TransformSortCriteria struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The column to be used in the sorting criteria that are associated with the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// machine learning transform.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Column TransformSortColumnType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The sort direction to be used in the sorting criteria that are associated with
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// the machine learning transform.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	SortDirection SortDirectionType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The sorting criteria that are associated with the machine learning transform.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TransformStatusType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TransformStatusType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TransformStatusTypeNotReady TransformStatusType = "NOT_READY"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TransformStatusTypeReady    TransformStatusType = "READY"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TransformStatusTypeDeleting TransformStatusType = "DELETING"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enum values for TransformStatusType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (TransformStatusType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for TransformStatusType. 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 TransformType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TransformType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	TransformTypeFindMatches TransformType = "FIND_MATCHES"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enum values for TransformType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (TransformType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (TransformType) Values() []TransformType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Values returns all known values for TransformType. 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 Trigger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Trigger struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The actions initiated by this trigger.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Actions []Action
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// A description of this trigger.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Reserved for future use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Id *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The name of the trigger.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The predicate of this trigger, which defines when it will fire.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Predicate *Predicate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// A cron expression used to specify the schedule (see Time-Based Schedules for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Jobs and Crawlers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// (https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// For example, to run something every day at 12:15 UTC, you would specify: cron(15
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// 12 * * ? *).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Schedule *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The current state of the trigger.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	State TriggerState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The type of trigger that this is.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Type TriggerType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The name of the workflow associated with the trigger.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	WorkflowName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Information about a specific trigger.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TriggerNodeDetails

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TriggerNodeDetails struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The information of the trigger represented by the trigger node.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Trigger *Trigger
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The details of a Trigger node present in the workflow.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TriggerState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TriggerState string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TriggerStateCreating     TriggerState = "CREATING"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TriggerStateCreated      TriggerState = "CREATED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TriggerStateActivating   TriggerState = "ACTIVATING"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TriggerStateActivated    TriggerState = "ACTIVATED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TriggerStateDeactivating TriggerState = "DEACTIVATING"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TriggerStateDeactivated  TriggerState = "DEACTIVATED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TriggerStateDeleting     TriggerState = "DELETING"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TriggerStateUpdating     TriggerState = "UPDATING"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enum values for TriggerState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (TriggerState) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (TriggerState) Values() []TriggerState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for TriggerState. 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 TriggerType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TriggerType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TriggerTypeScheduled   TriggerType = "SCHEDULED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TriggerTypeConditional TriggerType = "CONDITIONAL"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TriggerTypeOnDemand    TriggerType = "ON_DEMAND"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enum values for TriggerType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (TriggerType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (TriggerType) Values() []TriggerType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for TriggerType. 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 TriggerUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TriggerUpdate struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The actions initiated by this trigger.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Actions []Action
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// A description of this trigger.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Reserved for future use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The predicate of this trigger, which defines when it will fire.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Predicate *Predicate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// A cron expression used to specify the schedule (see Time-Based Schedules for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Jobs and Crawlers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// (https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// For example, to run something every day at 12:15 UTC, you would specify: cron(15
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// 12 * * ? *).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Schedule *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A structure used to provide information used to update a trigger. This object updates the previous trigger definition by overwriting it completely.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type UpdateBehavior

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type UpdateBehavior string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	UpdateBehaviorLog              UpdateBehavior = "LOG"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	UpdateBehaviorUpdateInDatabase UpdateBehavior = "UPDATE_IN_DATABASE"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for UpdateBehavior

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (UpdateBehavior) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (UpdateBehavior) Values() []UpdateBehavior

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for UpdateBehavior. 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 UpdateCsvClassifierRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type UpdateCsvClassifierRequest struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The name of the classifier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Enables the processing of files that contain only one column.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	AllowSingleColumn *bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Indicates whether the CSV file contains a header.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ContainsHeader CsvHeaderOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// A custom symbol to denote what separates each column entry in the row.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Delimiter *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Specifies not to trim values before identifying the type of column values. The
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// default value is true.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	DisableValueTrimming *bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// A list of strings representing column names.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Header []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// A custom symbol to denote what combines content into a single column value. It
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// must be different from the column delimiter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	QuoteSymbol *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Specifies a custom CSV classifier to be updated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type UpdateGrokClassifierRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type UpdateGrokClassifierRequest struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The name of the GrokClassifier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// An identifier of the data format that the classifier matches, such as Twitter,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// JSON, Omniture logs, Amazon CloudWatch Logs, and so on.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Classification *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Optional custom grok patterns used by this classifier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	CustomPatterns *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The grok pattern used by this classifier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	GrokPattern *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Specifies a grok classifier to update when passed to UpdateClassifier.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type UpdateJsonClassifierRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type UpdateJsonClassifierRequest struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The name of the classifier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// A JsonPath string defining the JSON data for the classifier to classify. AWS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Glue supports a subset of JsonPath, as described in Writing JsonPath Custom
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Classifiers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// (https://docs.aws.amazon.com/glue/latest/dg/custom-classifier.html#custom-classifier-json).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	JsonPath *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specifies a JSON classifier to be updated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type UpdateXMLClassifierRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type UpdateXMLClassifierRequest struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name of the classifier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// An identifier of the data format that the classifier matches.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Classification *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The XML tag designating the element that contains each record in an XML document
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// being parsed. This cannot identify a self-closing element (closed by />). An
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// empty row element that contains only attributes can be parsed as long as it ends
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// with a closing tag (for example,  is okay, but  is not).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	RowTag *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Specifies an XML classifier to be updated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type UserDefinedFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type UserDefinedFunction struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The ID of the Data Catalog in which the function resides.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CatalogId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The Java class that contains the function code.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ClassName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The time at which the function was created.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CreateTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The name of the catalog database that contains the function.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	DatabaseName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The name of the function.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	FunctionName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The owner of the function.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	OwnerName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The owner type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	OwnerType PrincipalType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The resource URIs for the function.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ResourceUris []ResourceUri
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Represents the equivalent of a Hive user-defined function (UDF) definition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type UserDefinedFunctionInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type UserDefinedFunctionInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The Java class that contains the function code.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ClassName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The name of the function.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FunctionName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The owner of the function.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	OwnerName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The owner type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	OwnerType PrincipalType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The resource URIs for the function.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ResourceUris []ResourceUri
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A structure used to create or update a user-defined function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ValidationException

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ValidationException struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A value could not be validated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*ValidationException) Error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (e *ValidationException) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*ValidationException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (e *ValidationException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*ValidationException) ErrorFault

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*ValidationException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (e *ValidationException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type VersionMismatchException

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type VersionMismatchException struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            There was a version conflict.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*VersionMismatchException) Error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (e *VersionMismatchException) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*VersionMismatchException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (e *VersionMismatchException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*VersionMismatchException) ErrorFault

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*VersionMismatchException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (e *VersionMismatchException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type WorkerType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type WorkerType string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	WorkerTypeStandard WorkerType = "Standard"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	WorkerTypeG1x      WorkerType = "G.1X"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	WorkerTypeG2x      WorkerType = "G.2X"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enum values for WorkerType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (WorkerType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (WorkerType) Values() []WorkerType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Values returns all known values for WorkerType. 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 Workflow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Workflow struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The date and time when the workflow was created.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CreatedOn *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// A collection of properties to be used as part of each execution of the workflow.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DefaultRunProperties map[string]string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// A description of the workflow.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The graph representing all the AWS Glue components that belong to the workflow
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// as nodes and directed connections between them as edges.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Graph *WorkflowGraph
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The date and time when the workflow was last modified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	LastModifiedOn *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The information about the last execution of the workflow.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	LastRun *WorkflowRun
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// You can use this parameter to prevent unwanted multiple updates to data, to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// control costs, or in some cases, to prevent exceeding the maximum number of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// concurrent runs of any of the component jobs. If you leave this parameter blank,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// there is no limit to the number of concurrent workflow runs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	MaxConcurrentRuns *int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The name of the workflow representing the flow.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  A workflow represents a flow in which AWS Glue components should be executed to complete a logical task.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type WorkflowGraph

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type WorkflowGraph struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// A list of all the directed connections between the nodes belonging to the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// workflow.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Edges []Edge
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// A list of the the AWS Glue components belong to the workflow represented as
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// nodes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Nodes []Node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A workflow graph represents the complete workflow containing all the AWS Glue components present in the workflow and all the directed connections between them.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type WorkflowRun

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type WorkflowRun struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The date and time when the workflow run completed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CompletedOn *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// This error message describes any error that may have occurred in starting the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// workflow run. Currently the only error message is "Concurrent runs exceeded for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// workflow: foo."
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ErrorMessage *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The graph representing all the AWS Glue components that belong to the workflow
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// as nodes and directed connections between them as edges.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Graph *WorkflowGraph
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Name of the workflow that was executed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The ID of the previous workflow run.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	PreviousRunId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The date and time when the workflow run was started.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	StartedOn *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The statistics of the run.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Statistics *WorkflowRunStatistics
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The status of the workflow run.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Status WorkflowRunStatus
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The ID of this workflow run.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	WorkflowRunId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The workflow run properties which were set during the run.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	WorkflowRunProperties map[string]string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A workflow run is an execution of a workflow providing all the runtime information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type WorkflowRunStatistics

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type WorkflowRunStatistics struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Total number of Actions that have failed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FailedActions int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Total number Actions in running state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	RunningActions int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Total number of Actions that have stopped.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	StoppedActions int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Total number of Actions that have succeeded.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	SucceededActions int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Total number of Actions that timed out.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	TimeoutActions int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Total number of Actions in the workflow run.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	TotalActions int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Workflow run statistics provides statistics about the workflow run.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type WorkflowRunStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type WorkflowRunStatus string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	WorkflowRunStatusRunning   WorkflowRunStatus = "RUNNING"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	WorkflowRunStatusCompleted WorkflowRunStatus = "COMPLETED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	WorkflowRunStatusStopping  WorkflowRunStatus = "STOPPING"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	WorkflowRunStatusStopped   WorkflowRunStatus = "STOPPED"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	WorkflowRunStatusError     WorkflowRunStatus = "ERROR"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for WorkflowRunStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (WorkflowRunStatus) Values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for WorkflowRunStatus. 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 XMLClassifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type XMLClassifier struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// An identifier of the data format that the classifier matches.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Classification *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The name of the classifier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The time that this classifier was registered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CreationTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The time that this classifier was last updated.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	LastUpdated *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The XML tag designating the element that contains each record in an XML document
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// being parsed. This can't identify a self-closing element (closed by />). An
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// empty row element that contains only attributes can be parsed as long as it ends
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// with a closing tag (for example,  is okay, but  is not).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	RowTag *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The version of this classifier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Version int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A classifier for XML content.