type AccessDeniedException struct {
	Message *string
}

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
}

type AlreadyExistsException struct {
	Message *string
}

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
}

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
}

type BatchUpdatePartitionFailureEntry struct {

	// The details about the batch update partition error.
	ErrorDetail *ErrorDetail

	// A list of values defining the partitions.
	PartitionValueList []*string
}

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
}

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
}

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
}

type CatalogEncryptionMode string

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

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
}

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
}

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
}

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
}

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
}

type CloudWatchEncryptionMode string

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

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
}

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
}

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
}

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
}

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
}

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
}

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
}

type ColumnStatisticsError struct {

	// The ColumnStatistics of the column.
	ColumnStatistics *ColumnStatistics

	// An error message with the reason for the failure of an operation.
	Error *ErrorDetail
}

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"
)

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"
)

type ConcurrentModificationException struct {
	Message *string
}

type ConcurrentRunsExceededException struct {
	Message *string
}

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
}

type ConditionCheckFailureException struct {
	Message *string
}

type ConflictException struct {
	Message *string
}

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
}

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
}

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
}

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
}

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"
)

type ConnectionType string

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

type ConnectionsList struct {

	// A list of connections used by the job.
	Connections []*string
}

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
}

type CrawlState string

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

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

	// 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
}

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
}

type CrawlerNodeDetails struct {

	// A list of crawls represented by the crawl node.
	Crawls []*Crawl
}

type CrawlerNotRunningException struct {
	Message *string
}

type CrawlerRunningException struct {
	Message *string
}

type CrawlerState string

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

type CrawlerStoppingException struct {
	Message *string
}

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
}

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
}

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
}

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
}

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
}

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
}

type CsvHeaderOption string

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

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
}

type DataLakePrincipal struct {

	// An identifier for the AWS Lake Formation principal.
	DataLakePrincipalIdentifier *string
}

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
}

type DatabaseIdentifier struct {

	// The ID of the Data Catalog in which the database resides.
	CatalogId *string

	// The name of the catalog database.
	DatabaseName *string
}

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
}

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
}

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
}

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
}

type DeleteBehavior string

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

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
}

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
}

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
}

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
}

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
}

type EnableHybridValues string

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

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
}

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
}

type EntityNotFoundException struct {
	Message *string
}

type ErrorDetail struct {

	// The code associated with this error.
	ErrorCode *string

	// A message describing the error.
	ErrorMessage *string
}

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
}

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
}

type ExistCondition string

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

type ExportLabelsTaskRunProperties struct {

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

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

	// 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
}

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
}

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
}

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
}

type GlueEncryptionException struct {
	Message *string
}

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
}

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
}

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
}

type IdempotentParameterMismatchException struct {
	Message *string
}

type IllegalWorkflowStateException struct {
	Message *string
}

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
}

type InternalServiceException struct {
	Message *string
}

type InvalidInputException struct {
	Message *string
}

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
}

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/).
	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
}

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
}

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
}

type JobBookmarksEncryptionMode string

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

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
}

type JobNodeDetails struct {

	// The information for the job runs represented by the job node.
	JobRuns []*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/).
	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
}

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"
)

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/).
	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
}

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
}

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
}

type LabelingSetGenerationTaskRunProperties struct {

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

type Language string

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

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
}

type LastCrawlStatus string

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

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
}

type Logical string

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

type LogicalOperator string

const (
	LogicalOperatorEquals LogicalOperator = "EQUALS"
)

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
}

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
}

type MLTransformNotReadyException struct {
	Message *string
}

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
}

type MLUserDataEncryptionModeString string

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

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
}

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
}

type NoScheduleException struct {
	Message *string
}

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
}

type NodeType string

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

type NotificationProperty struct {

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

type OperationTimeoutException struct {
	Message *string
}

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
}

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
}

type PartitionError struct {

	// The details about the partition error.
	ErrorDetail *ErrorDetail

	// The values that define the partition.
	PartitionValues []*string
}

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
}

type PartitionIndexDescriptor struct {

	// The name of the partition index.
	//
	// This member is required.
	IndexName *string

	// The status of the partition index.
	//
	// 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
}

type PartitionIndexStatus string

const (
	PartitionIndexStatusActive PartitionIndexStatus = "ACTIVE"
)

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
}

type PartitionValueList struct {

	// The list of values.
	//
	// This member is required.
	Values []*string
}

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"
)

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
}

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
}

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
}

type PrincipalPermissions struct {

	// The permissions that are granted to the principal.
	Permissions []Permission

	// The principal who is granted permissions.
	Principal *DataLakePrincipal
}

type PrincipalType string

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

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
}

type RecrawlBehavior string

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

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
}

type ResourceNumberLimitExceededException struct {
	Message *string
}

type ResourceShareType string

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

type ResourceType string

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

type ResourceUri struct {

	// The type of the resource.
	ResourceType ResourceType

	// The URI for accessing the resource.
	Uri *string
}

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
}

type S3EncryptionMode string

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

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
}

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
}

type ScheduleState string

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

type SchedulerNotRunningException struct {
	Message *string
}

type SchedulerRunningException struct {
	Message *string
}

type SchedulerTransitioningException struct {
	Message *string
}

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
}

type SchemaColumn struct {

	// The type of data in the column.
	DataType *string

	// The name of the column.
	Name *string
}

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
}

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
}

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
}

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
}

type Sort string

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

type SortCriterion struct {

	// The name of the field on which to sort.
	FieldName *string

	// An ascending or descending sort.
	Sort Sort
}

type SortDirectionType string

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

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

	// 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
}

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
}

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
}

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
}

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
}

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
}

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
}

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
}

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
}

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
}

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
}

type TaskRunSortColumnType string

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

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
}

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"
)

type TaskType string

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

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
}

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
}

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
}

type TransformSortColumnType string

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

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
}

type TransformStatusType string

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

type TransformType string

const (
	TransformTypeFindMatches TransformType = "FIND_MATCHES"
)

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
}

type TriggerNodeDetails struct {

	// The information of the trigger represented by the trigger node.
	Trigger *Trigger
}

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"
)

type TriggerType string

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

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
}

type UpdateBehavior string

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

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
}

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
}

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
}

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
}

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
}

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
}

type ValidationException struct {
	Message *string
}

type VersionMismatchException struct {
	Message *string
}

type WorkerType string

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

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
}

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
}

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
}

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
}

type WorkflowRunStatus string

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

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
}