const ServiceAPIVersion = "2017-03-31"

const ServiceID = "Glue"

type BatchCreatePartitionInput struct {

	// The name of the metadata database in which the partition is to be created.
	//
	// This member is required.
	DatabaseName *string

	// A list of PartitionInput structures that define the partitions to be created.
	//
	// This member is required.
	PartitionInputList []types.PartitionInput

	// The name of the metadata table in which the partition is to be created.
	//
	// This member is required.
	TableName *string

	// The ID of the catalog in which the partition is to be created. Currently, this
	// should be the AWS account ID.
	CatalogId *string
}

type BatchCreatePartitionOutput struct {

	// The errors encountered when trying to create the requested partitions.
	Errors []types.PartitionError

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type BatchDeleteConnectionInput struct {

	// A list of names of the connections to delete.
	//
	// This member is required.
	ConnectionNameList []string

	// The ID of the Data Catalog in which the connections reside. If none is provided,
	// the AWS account ID is used by default.
	CatalogId *string
}

type BatchDeleteConnectionOutput struct {

	// A map of the names of connections that were not successfully deleted to error
	// details.
	Errors map[string]types.ErrorDetail

	// A list of names of the connection definitions that were successfully deleted.
	Succeeded []string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type BatchDeletePartitionInput struct {

	// The name of the catalog database in which the table in question resides.
	//
	// This member is required.
	DatabaseName *string

	// A list of PartitionInput structures that define the partitions to be deleted.
	//
	// This member is required.
	PartitionsToDelete []types.PartitionValueList

	// The name of the table that contains the partitions to be deleted.
	//
	// This member is required.
	TableName *string

	// The ID of the Data Catalog where the partition to be deleted resides. If none is
	// provided, the AWS account ID is used by default.
	CatalogId *string
}

type BatchDeletePartitionOutput struct {

	// The errors encountered when trying to delete the requested partitions.
	Errors []types.PartitionError

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type BatchDeleteTableInput struct {

	// The name of the catalog database in which the tables to delete reside. For Hive
	// compatibility, this name is entirely lowercase.
	//
	// This member is required.
	DatabaseName *string

	// A list of the table to delete.
	//
	// This member is required.
	TablesToDelete []string

	// The ID of the Data Catalog where the table resides. If none is provided, the AWS
	// account ID is used by default.
	CatalogId *string
}

type BatchDeleteTableOutput struct {

	// A list of errors encountered in attempting to delete the specified tables.
	Errors []types.TableError

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type BatchDeleteTableVersionInput struct {

	// The database in the catalog in which the table resides. For Hive compatibility,
	// this name is entirely lowercase.
	//
	// This member is required.
	DatabaseName *string

	// The name of the table. For Hive compatibility, this name is entirely lowercase.
	//
	// This member is required.
	TableName *string

	// A list of the IDs of versions to be deleted. A VersionId is a string
	// representation of an integer. Each version is incremented by 1.
	//
	// This member is required.
	VersionIds []string

	// The ID of the Data Catalog where the tables reside. If none is provided, the AWS
	// account ID is used by default.
	CatalogId *string
}

type BatchDeleteTableVersionOutput struct {

	// A list of errors encountered while trying to delete the specified table
	// versions.
	Errors []types.TableVersionError

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type BatchGetCrawlersInput struct {

	// A list of crawler names, which might be the names returned from the ListCrawlers
	// operation.
	//
	// This member is required.
	CrawlerNames []string
}

type BatchGetCrawlersOutput struct {

	// A list of crawler definitions.
	Crawlers []types.Crawler

	// A list of names of crawlers that were not found.
	CrawlersNotFound []string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type BatchGetDevEndpointsInput struct {

	// The list of DevEndpoint names, which might be the names returned from the
	// ListDevEndpoint operation.
	//
	// This member is required.
	DevEndpointNames []string
}

type BatchGetDevEndpointsOutput struct {

	// A list of DevEndpoint definitions.
	DevEndpoints []types.DevEndpoint

	// A list of DevEndpoints not found.
	DevEndpointsNotFound []string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type BatchGetJobsInput struct {

	// A list of job names, which might be the names returned from the ListJobs
	// operation.
	//
	// This member is required.
	JobNames []string
}

type BatchGetJobsOutput struct {

	// A list of job definitions.
	Jobs []types.Job

	// A list of names of jobs not found.
	JobsNotFound []string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type BatchGetPartitionInput struct {

	// The name of the catalog database where the partitions reside.
	//
	// This member is required.
	DatabaseName *string

	// A list of partition values identifying the partitions to retrieve.
	//
	// This member is required.
	PartitionsToGet []types.PartitionValueList

	// The name of the partitions' table.
	//
	// This member is required.
	TableName *string

	// The ID of the Data Catalog where the partitions in question reside. If none is
	// supplied, the AWS account ID is used by default.
	CatalogId *string
}

type BatchGetPartitionOutput struct {

	// A list of the requested partitions.
	Partitions []types.Partition

	// A list of the partition values in the request for which partitions were not
	// returned.
	UnprocessedKeys []types.PartitionValueList

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type BatchGetTriggersInput struct {

	// A list of trigger names, which may be the names returned from the ListTriggers
	// operation.
	//
	// This member is required.
	TriggerNames []string
}

type BatchGetTriggersOutput struct {

	// A list of trigger definitions.
	Triggers []types.Trigger

	// A list of names of triggers not found.
	TriggersNotFound []string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type BatchGetWorkflowsInput struct {

	// A list of workflow names, which may be the names returned from the ListWorkflows
	// operation.
	//
	// This member is required.
	Names []string

	// Specifies whether to include a graph when returning the workflow resource
	// metadata.
	IncludeGraph *bool
}

type BatchGetWorkflowsOutput struct {

	// A list of names of workflows not found.
	MissingWorkflows []string

	// A list of workflow resource metadata.
	Workflows []types.Workflow

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type BatchStopJobRunInput struct {

	// The name of the job definition for which to stop job runs.
	//
	// This member is required.
	JobName *string

	// A list of the JobRunIds that should be stopped for that job definition.
	//
	// This member is required.
	JobRunIds []string
}

type BatchStopJobRunOutput struct {

	// A list of the errors that were encountered in trying to stop JobRuns, including
	// the JobRunId for which each error was encountered and details about the error.
	Errors []types.BatchStopJobRunError

	// A list of the JobRuns that were successfully submitted for stopping.
	SuccessfulSubmissions []types.BatchStopJobRunSuccessfulSubmission

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type BatchUpdatePartitionInput struct {

	// The name of the metadata database in which the partition is to be updated.
	//
	// This member is required.
	DatabaseName *string

	// A list of up to 100 BatchUpdatePartitionRequestEntry objects to update.
	//
	// This member is required.
	Entries []types.BatchUpdatePartitionRequestEntry

	// The name of the metadata table in which the partition is to be updated.
	//
	// This member is required.
	TableName *string

	// The ID of the catalog in which the partition is to be updated. Currently, this
	// should be the AWS account ID.
	CatalogId *string
}

type BatchUpdatePartitionOutput struct {

	// The errors encountered when trying to update the requested partitions. A list of
	// BatchUpdatePartitionFailureEntry objects.
	Errors []types.BatchUpdatePartitionFailureEntry

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CancelMLTaskRunInput struct {

	// A unique identifier for the task run.
	//
	// This member is required.
	TaskRunId *string

	// The unique identifier of the machine learning transform.
	//
	// This member is required.
	TransformId *string
}

type CancelMLTaskRunOutput struct {

	// The status for this run.
	Status types.TaskStatusType

	// The unique identifier for the task run.
	TaskRunId *string

	// The unique identifier of the machine learning transform.
	TransformId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CheckSchemaVersionValidityInput struct {

	// The data format of the schema definition. Currently only AVRO is supported.
	//
	// This member is required.
	DataFormat types.DataFormat

	// The definition of the schema that has to be validated.
	//
	// This member is required.
	SchemaDefinition *string
}

type CheckSchemaVersionValidityOutput struct {

	// A validation failure error message.
	Error *string

	// Return true, if the schema is valid and false otherwise.
	Valid bool

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type Client struct {
	// contains filtered or unexported fields
}

type CreateClassifierInput struct {

	// A CsvClassifier object specifying the classifier to create.
	CsvClassifier *types.CreateCsvClassifierRequest

	// A GrokClassifier object specifying the classifier to create.
	GrokClassifier *types.CreateGrokClassifierRequest

	// A JsonClassifier object specifying the classifier to create.
	JsonClassifier *types.CreateJsonClassifierRequest

	// An XMLClassifier object specifying the classifier to create.
	XMLClassifier *types.CreateXMLClassifierRequest
}

type CreateClassifierOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateConnectionInput struct {

	// A ConnectionInput object defining the connection to create.
	//
	// This member is required.
	ConnectionInput *types.ConnectionInput

	// The ID of the Data Catalog in which to create the connection. If none is
	// provided, the AWS account ID is used by default.
	CatalogId *string
}

type CreateConnectionOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateCrawlerInput struct {

	// Name of the new crawler.
	//
	// This member is required.
	Name *string

	// The IAM role or Amazon Resource Name (ARN) of an IAM role used by the new
	// crawler to access customer resources.
	//
	// This member is required.
	Role *string

	// A list of collection of targets to crawl.
	//
	// This member is required.
	Targets *types.CrawlerTargets

	// A list of custom classifiers that the user has registered. By default, all
	// built-in classifiers are included in a crawl, but these custom classifiers
	// always override the default classifiers for a given classification.
	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

	// The name of the SecurityConfiguration structure to be used by this crawler.
	CrawlerSecurityConfiguration *string

	// The AWS Glue database where results are written, such as:
	// arn:aws:daylight:us-east-1::database/sometable/*.
	DatabaseName *string

	// A description of the new crawler.
	Description *string

	// Specifies data lineage configuration settings for the crawler.
	LineageConfiguration *types.LineageConfiguration

	// 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 *types.RecrawlPolicy

	// 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 policy for the crawler's update and deletion behavior.
	SchemaChangePolicy *types.SchemaChangePolicy

	// The table prefix used for catalog tables that are created.
	TablePrefix *string

	// The tags to use with this crawler request. You may use tags to limit access to
	// the crawler. For more information about tags in AWS Glue, see AWS Tags in AWS
	// Glue (https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html) in the
	// developer guide.
	Tags map[string]string
}

type CreateCrawlerOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateDatabaseInput struct {

	// The metadata for the database.
	//
	// This member is required.
	DatabaseInput *types.DatabaseInput

	// The ID of the Data Catalog in which to create the database. If none is provided,
	// the AWS account ID is used by default.
	CatalogId *string
}

type CreateDatabaseOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateDevEndpointInput struct {

	// The name to be assigned to the new DevEndpoint.
	//
	// This member is required.
	EndpointName *string

	// The IAM role for the DevEndpoint.
	//
	// This member is required.
	RoleArn *string

	// A map of arguments used to configure the DevEndpoint.
	Arguments map[string]string

	// The path to one or more Java .jar files in an S3 bucket that should be loaded in
	// your 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 yet supported.
	ExtraPythonLibsS3Path *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 number of AWS Glue Data Processing Units (DPUs) to allocate 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

	// 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 development endpoints for
	// authentication. The use of 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 with the
	// public key content in the deletePublicKeys attribute, and the list of new keys
	// in the addPublicKeys attribute.
	PublicKeys []string

	// The name of the SecurityConfiguration structure to be used with this
	// DevEndpoint.
	SecurityConfiguration *string

	// Security group IDs for the security groups to be used by the new DevEndpoint.
	SecurityGroupIds []string

	// The subnet ID for the new DevEndpoint to use.
	SubnetId *string

	// The tags to use with this DevEndpoint. You may use tags to limit access to the
	// DevEndpoint. For more information about tags in AWS Glue, see AWS Tags in AWS
	// Glue (https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html) in the
	// developer guide.
	Tags map[string]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 types.WorkerType
}

type CreateDevEndpointOutput struct {

	// The map of arguments used to configure this 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 assigned to the new DevEndpoint.
	EndpointName *string

	// Path to one or more Java .jar files in an S3 bucket that will be loaded in your
	// DevEndpoint.
	ExtraJarsS3Path *string

	// The paths to one or more Python libraries in an S3 bucket that will be loaded in
	// your DevEndpoint.
	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.
	GlueVersion *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.
	NumberOfWorkers *int32

	// The Amazon Resource Name (ARN) of the role assigned to the new DevEndpoint.
	RoleArn *string

	// The name of the SecurityConfiguration structure being used with this
	// DevEndpoint.
	SecurityConfiguration *string

	// The security groups assigned to the new DevEndpoint.
	SecurityGroupIds []string

	// The current status of the new DevEndpoint.
	Status *string

	// The subnet ID assigned to the new 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. May
	// be a value of Standard, G.1X, or G.2X.
	WorkerType types.WorkerType

	// The address of the YARN endpoint used by this DevEndpoint.
	YarnEndpointAddress *string

	// The Apache Zeppelin port for the remote Apache Spark interpreter.
	ZeppelinRemoteSparkInterpreterPort int32

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateJobInput struct {

	// The JobCommand that executes this job.
	//
	// This member is required.
	Command *types.JobCommand

	// The name you assign to this job definition. It must be unique in your account.
	//
	// This member is required.
	Name *string

	// The name or Amazon Resource Name (ARN) of the IAM role associated with this job.
	//
	// This member is required.
	Role *string

	// This parameter is deprecated. Use MaxCapacity instead. The number of AWS Glue
	// data processing units (DPUs) to allocate to this Job. You can allocate from 2 to
	// 100 DPUs; the default is 10. A DPU is a relative measure of processing power
	// that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more
	// information, see the AWS Glue pricing page
	// (https://aws.amazon.com/glue/pricing/).
	//
	// Deprecated: This property is deprecated, use MaxCapacity instead.
	AllocatedCapacity int32

	// The connections used for this job.
	Connections *types.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 *types.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

	// 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 configuration properties of a job notification.
	NotificationProperty *types.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 of the SecurityConfiguration structure to be used with this job.
	SecurityConfiguration *string

	// The tags to use with this job. You may use tags to limit access to the job. For
	// more information about tags in AWS Glue, see AWS Tags in AWS Glue
	// (https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html) in the developer
	// guide.
	Tags map[string]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 types.WorkerType
}

type CreateJobOutput struct {

	// The unique name that was provided for this job definition.
	Name *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateMLTransformInput struct {

	// A list of AWS Glue table definitions used by the transform.
	//
	// This member is required.
	InputRecordTables []types.GlueTable

	// The unique name that you give the transform when you create it.
	//
	// This member is required.
	Name *string

	// The algorithmic parameters that are specific to the transform type used.
	// Conditionally dependent on the transform type.
	//
	// This member is required.
	Parameters *types.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.
	//
	// This member is required.
	Role *string

	// A description of the machine learning transform that is being defined. The
	// default is an empty string.
	Description *string

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

	// 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 (https://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. 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 a task for this transform after a task run
	// fails.
	MaxRetries *int32

	// The number of workers of a defined workerType that are allocated when this task
	// runs. If WorkerType is set, then NumberOfWorkers is required (and vice versa).
	NumberOfWorkers *int32

	// The tags to use with this machine learning transform. You may use tags to limit
	// access to the machine learning transform. For more information about tags in AWS
	// Glue, see AWS Tags in AWS Glue
	// (https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html) in the developer
	// guide.
	Tags map[string]string

	// The timeout of the task run for this transform in minutes. This is the maximum
	// time that a task run for this transform can consume resources before it is
	// terminated and enters TIMEOUT status. The default is 2,880 minutes (48 hours).
	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 *types.TransformEncryption

	// The type of predefined worker that is allocated when this task 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 types.WorkerType
}

type CreateMLTransformOutput struct {

	// A unique identifier that is generated for the transform.
	TransformId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreatePartitionIndexInput struct {

	// Specifies the name of a database in which you want to create a partition index.
	//
	// This member is required.
	DatabaseName *string

	// Specifies a PartitionIndex structure to create a partition index in an existing
	// table.
	//
	// This member is required.
	PartitionIndex *types.PartitionIndex

	// Specifies the name of a table in which you want to create a partition index.
	//
	// This member is required.
	TableName *string

	// The catalog ID where the table resides.
	CatalogId *string
}

type CreatePartitionIndexOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreatePartitionInput struct {

	// The name of the metadata database in which the partition is to be created.
	//
	// This member is required.
	DatabaseName *string

	// A PartitionInput structure defining the partition to be created.
	//
	// This member is required.
	PartitionInput *types.PartitionInput

	// The name of the metadata table in which the partition is to be created.
	//
	// This member is required.
	TableName *string

	// The AWS account ID of the catalog in which the partition is to be created.
	CatalogId *string
}

type CreatePartitionOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateRegistryInput struct {

	// Name of the registry to be created of max length of 255, and may only contain
	// letters, numbers, hyphen, underscore, dollar sign, or hash mark. No whitespace.
	//
	// This member is required.
	RegistryName *string

	// A description of the registry. If description is not provided, there will not be
	// any default value for this.
	Description *string

	// AWS tags that contain a key value pair and may be searched by console, command
	// line, or API.
	Tags map[string]string
}

type CreateRegistryOutput struct {

	// A description of the registry.
	Description *string

	// The Amazon Resource Name (ARN) of the newly created registry.
	RegistryArn *string

	// The name of the registry.
	RegistryName *string

	// The tags for the registry.
	Tags map[string]string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateSchemaInput struct {

	// The data format of the schema definition. Currently only AVRO is supported.
	//
	// This member is required.
	DataFormat types.DataFormat

	// Name of the schema to be created of max length of 255, and may only contain
	// letters, numbers, hyphen, underscore, dollar sign, or hash mark. No whitespace.
	//
	// This member is required.
	SchemaName *string

	// The compatibility mode of the schema. The possible values are:
	//
	// * NONE: No
	// compatibility mode applies. You can use this choice in development scenarios or
	// if you do not know the compatibility mode that you want to apply to schemas. Any
	// new version added will be accepted without undergoing a compatibility check.
	//
	// *
	// DISABLED: This compatibility choice prevents versioning for a particular schema.
	// You can use this choice to prevent future versioning of a schema.
	//
	// * BACKWARD:
	// This compatibility choice is recommended as it allows data receivers to read
	// both the current and one previous schema version. This means that for instance,
	// a new schema version cannot drop data fields or change the type of these fields,
	// so they can't be read by readers using the previous version.
	//
	// * BACKWARD_ALL:
	// This compatibility choice allows data receivers to read both the current and all
	// previous schema versions. You can use this choice when you need to delete fields
	// or add optional fields, and check compatibility against all previous schema
	// versions.
	//
	// * FORWARD: This compatibility choice allows data receivers to read
	// both the current and one next schema version, but not necessarily later
	// versions. You can use this choice when you need to add fields or delete optional
	// fields, but only check compatibility against the last schema version.
	//
	// *
	// FORWARD_ALL: This compatibility choice allows data receivers to read written by
	// producers of any new registered schema. You can use this choice when you need to
	// add fields or delete optional fields, and check compatibility against all
	// previous schema versions.
	//
	// * FULL: This compatibility choice allows data
	// receivers to read data written by producers using the previous or next version
	// of the schema, but not necessarily earlier or later versions. You can use this
	// choice when you need to add or remove optional fields, but only check
	// compatibility against the last schema version.
	//
	// * FULL_ALL: This compatibility
	// choice allows data receivers to read data written by producers using all
	// previous schema versions. You can use this choice when you need to add or remove
	// optional fields, and check compatibility against all previous schema versions.
	Compatibility types.Compatibility

	// An optional description of the schema. If description is not provided, there
	// will not be any automatic default value for this.
	Description *string

	// This is a wrapper shape to contain the registry identity fields. If this is not
	// provided, the default registry will be used. The ARN format for the same will
	// be: arn:aws:glue:us-east-2::registry/default-registry:random-5-letter-id.
	RegistryId *types.RegistryId

	// The schema definition using the DataFormat setting for SchemaName.
	SchemaDefinition *string

	// AWS tags that contain a key value pair and may be searched by console, command
	// line, or API. If specified, follows the AWS tags-on-create pattern.
	Tags map[string]string
}

type CreateSchemaOutput struct {

	// The schema compatibility mode.
	Compatibility types.Compatibility

	// The data format of the schema definition. Currently only AVRO is supported.
	DataFormat types.DataFormat

	// A description of the schema if specified when created.
	Description *string

	// The latest version of the schema associated with the returned schema definition.
	LatestSchemaVersion int64

	// The next version of the schema associated with the returned schema definition.
	NextSchemaVersion int64

	// The Amazon Resource Name (ARN) of the registry.
	RegistryArn *string

	// The name of the registry.
	RegistryName *string

	// The Amazon Resource Name (ARN) of the schema.
	SchemaArn *string

	// The version number of the checkpoint (the last time the compatibility mode was
	// changed).
	SchemaCheckpoint int64

	// The name of the schema.
	SchemaName *string

	// The status of the schema.
	SchemaStatus types.SchemaStatus

	// The unique identifier of the first schema version.
	SchemaVersionId *string

	// The status of the first schema version created.
	SchemaVersionStatus types.SchemaVersionStatus

	// The tags for the schema.
	Tags map[string]string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateScriptInput struct {

	// A list of the edges in the DAG.
	DagEdges []types.CodeGenEdge

	// A list of the nodes in the DAG.
	DagNodes []types.CodeGenNode

	// The programming language of the resulting code from the DAG.
	Language types.Language
}

type CreateScriptOutput struct {

	// The Python script generated from the DAG.
	PythonScript *string

	// The Scala code generated from the DAG.
	ScalaCode *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateSecurityConfigurationInput struct {

	// The encryption configuration for the new security configuration.
	//
	// This member is required.
	EncryptionConfiguration *types.EncryptionConfiguration

	// The name for the new security configuration.
	//
	// This member is required.
	Name *string
}

type CreateSecurityConfigurationOutput struct {

	// The time at which the new security configuration was created.
	CreatedTimestamp *time.Time

	// The name assigned to the new security configuration.
	Name *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateTableInput struct {

	// The catalog database in which to create the new table. For Hive compatibility,
	// this name is entirely lowercase.
	//
	// This member is required.
	DatabaseName *string

	// The TableInput object that defines the metadata table to create in the catalog.
	//
	// This member is required.
	TableInput *types.TableInput

	// The ID of the Data Catalog in which to create the Table. If none is supplied,
	// the AWS account ID is used by default.
	CatalogId *string

	// A list of partition indexes, PartitionIndex structures, to create in the table.
	PartitionIndexes []types.PartitionIndex
}

type CreateTableOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateTriggerInput struct {

	// The actions initiated by this trigger when it fires.
	//
	// This member is required.
	Actions []types.Action

	// The name of the trigger.
	//
	// This member is required.
	Name *string

	// The type of the new trigger.
	//
	// This member is required.
	Type types.TriggerType

	// A description of the new trigger.
	Description *string

	// A predicate to specify when the new trigger should fire. This field is required
	// when the trigger type is CONDITIONAL.
	Predicate *types.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 * * ? *). This field is required when the trigger type is SCHEDULED.
	Schedule *string

	// Set to true to start SCHEDULED and CONDITIONAL triggers when created. True is
	// not supported for ON_DEMAND triggers.
	StartOnCreation bool

	// The tags to use with this trigger. You may use tags to limit access to the
	// trigger. For more information about tags in AWS Glue, see AWS Tags in AWS Glue
	// (https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html) in the developer
	// guide.
	Tags map[string]string

	// The name of the workflow associated with the trigger.
	WorkflowName *string
}

type CreateTriggerOutput struct {

	// The name of the trigger.
	Name *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateUserDefinedFunctionInput struct {

	// The name of the catalog database in which to create the function.
	//
	// This member is required.
	DatabaseName *string

	// A FunctionInput object that defines the function to create in the Data Catalog.
	//
	// This member is required.
	FunctionInput *types.UserDefinedFunctionInput

	// The ID of the Data Catalog in which to create the function. If none is provided,
	// the AWS account ID is used by default.
	CatalogId *string
}

type CreateUserDefinedFunctionOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateWorkflowInput struct {

	// The name to be assigned to the workflow. It should be unique within your
	// account.
	//
	// This member is required.
	Name *string

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

	// 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 tags to be used with this workflow.
	Tags map[string]string
}

type CreateWorkflowOutput struct {

	// The name of the workflow which was provided as part of the request.
	Name *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteClassifierInput struct {

	// Name of the classifier to remove.
	//
	// This member is required.
	Name *string
}

type DeleteClassifierOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteColumnStatisticsForPartitionInput struct {

	// Name of the column.
	//
	// This member is required.
	ColumnName *string

	// The name of the catalog database where the partitions reside.
	//
	// This member is required.
	DatabaseName *string

	// A list of partition values identifying the partition.
	//
	// This member is required.
	PartitionValues []string

	// The name of the partitions' table.
	//
	// This member is required.
	TableName *string

	// The ID of the Data Catalog where the partitions in question reside. If none is
	// supplied, the AWS account ID is used by default.
	CatalogId *string
}

type DeleteColumnStatisticsForPartitionOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteColumnStatisticsForTableInput struct {

	// The name of the column.
	//
	// This member is required.
	ColumnName *string

	// The name of the catalog database where the partitions reside.
	//
	// This member is required.
	DatabaseName *string

	// The name of the partitions' table.
	//
	// This member is required.
	TableName *string

	// The ID of the Data Catalog where the partitions in question reside. If none is
	// supplied, the AWS account ID is used by default.
	CatalogId *string
}

type DeleteColumnStatisticsForTableOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteConnectionInput struct {

	// The name of the connection to delete.
	//
	// This member is required.
	ConnectionName *string

	// The ID of the Data Catalog in which the connection resides. If none is provided,
	// the AWS account ID is used by default.
	CatalogId *string
}

type DeleteConnectionOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteCrawlerInput struct {

	// The name of the crawler to remove.
	//
	// This member is required.
	Name *string
}

type DeleteCrawlerOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteDatabaseInput struct {

	// The name of the database to delete. For Hive compatibility, this must be all
	// lowercase.
	//
	// This member is required.
	Name *string

	// The ID of the Data Catalog in which the database resides. If none is provided,
	// the AWS account ID is used by default.
	CatalogId *string
}

type DeleteDatabaseOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteDevEndpointInput struct {

	// The name of the DevEndpoint.
	//
	// This member is required.
	EndpointName *string
}

type DeleteDevEndpointOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteJobInput struct {

	// The name of the job definition to delete.
	//
	// This member is required.
	JobName *string
}

type DeleteJobOutput struct {

	// The name of the job definition that was deleted.
	JobName *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteMLTransformInput struct {

	// The unique identifier of the transform to delete.
	//
	// This member is required.
	TransformId *string
}

type DeleteMLTransformOutput struct {

	// The unique identifier of the transform that was deleted.
	TransformId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeletePartitionIndexInput struct {

	// Specifies the name of a database from which you want to delete a partition
	// index.
	//
	// This member is required.
	DatabaseName *string

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

	// Specifies the name of a table from which you want to delete a partition index.
	//
	// This member is required.
	TableName *string

	// The catalog ID where the table resides.
	CatalogId *string
}

type DeletePartitionIndexOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeletePartitionInput struct {

	// The name of the catalog database in which the table in question resides.
	//
	// This member is required.
	DatabaseName *string

	// The values that define the partition.
	//
	// This member is required.
	PartitionValues []string

	// The name of the table that contains the partition to be deleted.
	//
	// This member is required.
	TableName *string

	// The ID of the Data Catalog where the partition to be deleted resides. If none is
	// provided, the AWS account ID is used by default.
	CatalogId *string
}

type DeletePartitionOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteRegistryInput struct {

	// This is a wrapper structure that may contain the registry name and Amazon
	// Resource Name (ARN).
	//
	// This member is required.
	RegistryId *types.RegistryId
}

type DeleteRegistryOutput struct {

	// The Amazon Resource Name (ARN) of the registry being deleted.
	RegistryArn *string

	// The name of the registry being deleted.
	RegistryName *string

	// The status of the registry. A successful operation will return the Deleting
	// status.
	Status types.RegistryStatus

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteResourcePolicyInput struct {

	// The hash value returned when this policy was set.
	PolicyHashCondition *string

	// The ARN of the AWS Glue resource for the resource policy to be deleted.
	ResourceArn *string
}

type DeleteResourcePolicyOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteSchemaInput struct {

	// This is a wrapper structure that may contain the schema name and Amazon Resource
	// Name (ARN).
	//
	// This member is required.
	SchemaId *types.SchemaId
}

type DeleteSchemaOutput struct {

	// The Amazon Resource Name (ARN) of the schema being deleted.
	SchemaArn *string

	// The name of the schema being deleted.
	SchemaName *string

	// The status of the schema.
	Status types.SchemaStatus

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteSchemaVersionsInput struct {

	// This is a wrapper structure that may contain the schema name and Amazon Resource
	// Name (ARN).
	//
	// This member is required.
	SchemaId *types.SchemaId

	// A version range may be supplied which may be of the format:
	//
	// * a single version
	// number, 5
	//
	// * a range, 5-8 : deletes versions 5, 6, 7, 8
	//
	// This member is required.
	Versions *string
}

type DeleteSchemaVersionsOutput struct {

	// A list of SchemaVersionErrorItem objects, each containing an error and schema
	// version.
	SchemaVersionErrors []types.SchemaVersionErrorItem

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteSecurityConfigurationInput struct {

	// The name of the security configuration to delete.
	//
	// This member is required.
	Name *string
}

type DeleteSecurityConfigurationOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteTableInput struct {

	// The name of the catalog database in which the table resides. For Hive
	// compatibility, this name is entirely lowercase.
	//
	// This member is required.
	DatabaseName *string

	// The name of the table to be deleted. For Hive compatibility, this name is
	// entirely lowercase.
	//
	// This member is required.
	Name *string

	// The ID of the Data Catalog where the table resides. If none is provided, the AWS
	// account ID is used by default.
	CatalogId *string
}

type DeleteTableOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteTableVersionInput struct {

	// The database in the catalog in which the table resides. For Hive compatibility,
	// this name is entirely lowercase.
	//
	// This member is required.
	DatabaseName *string

	// The name of the table. For Hive compatibility, this name is entirely lowercase.
	//
	// This member is required.
	TableName *string

	// The ID of the table version to be deleted. A VersionID is a string
	// representation of an integer. Each version is incremented by 1.
	//
	// This member is required.
	VersionId *string

	// The ID of the Data Catalog where the tables reside. If none is provided, the AWS
	// account ID is used by default.
	CatalogId *string
}

type DeleteTableVersionOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteTriggerInput struct {

	// The name of the trigger to delete.
	//
	// This member is required.
	Name *string
}

type DeleteTriggerOutput struct {

	// The name of the trigger that was deleted.
	Name *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteUserDefinedFunctionInput struct {

	// The name of the catalog database where the function is located.
	//
	// This member is required.
	DatabaseName *string

	// The name of the function definition to be deleted.
	//
	// This member is required.
	FunctionName *string

	// The ID of the Data Catalog where the function to be deleted is located. If none
	// is supplied, the AWS account ID is used by default.
	CatalogId *string
}

type DeleteUserDefinedFunctionOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteWorkflowInput struct {

	// Name of the workflow to be deleted.
	//
	// This member is required.
	Name *string
}

type DeleteWorkflowOutput struct {

	// Name of the workflow specified in input.
	Name *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type EndpointResolver interface {
	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
}

type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

type EndpointResolverOptions = internalendpoints.Options

type GetCatalogImportStatusInput struct {

	// The ID of the catalog to migrate. Currently, this should be the AWS account ID.
	CatalogId *string
}

type GetCatalogImportStatusOutput struct {

	// The status of the specified catalog migration.
	ImportStatus *types.CatalogImportStatus

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetClassifierInput struct {

	// Name of the classifier to retrieve.
	//
	// This member is required.
	Name *string
}

type GetClassifierOutput struct {

	// The requested classifier.
	Classifier *types.Classifier

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetClassifiersAPIClient interface {
	GetClassifiers(context.Context, *GetClassifiersInput, ...func(*Options)) (*GetClassifiersOutput, error)
}

type GetClassifiersInput struct {

	// The size of the list to return (optional).
	MaxResults *int32

	// An optional continuation token.
	NextToken *string
}

type GetClassifiersOutput struct {

	// The requested list of classifier objects.
	Classifiers []types.Classifier

	// A continuation token.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetClassifiersPaginator struct {
	// contains filtered or unexported fields
}

type GetClassifiersPaginatorOptions struct {
	// The size of the list to return (optional).
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetColumnStatisticsForPartitionInput struct {

	// A list of the column names.
	//
	// This member is required.
	ColumnNames []string

	// The name of the catalog database where the partitions reside.
	//
	// This member is required.
	DatabaseName *string

	// A list of partition values identifying the partition.
	//
	// This member is required.
	PartitionValues []string

	// The name of the partitions' table.
	//
	// This member is required.
	TableName *string

	// The ID of the Data Catalog where the partitions in question reside. If none is
	// supplied, the AWS account ID is used by default.
	CatalogId *string
}

type GetColumnStatisticsForPartitionOutput struct {

	// List of ColumnStatistics that failed to be retrieved.
	ColumnStatisticsList []types.ColumnStatistics

	// Error occurred during retrieving column statistics data.
	Errors []types.ColumnError

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetColumnStatisticsForTableInput struct {

	// A list of the column names.
	//
	// This member is required.
	ColumnNames []string

	// The name of the catalog database where the partitions reside.
	//
	// This member is required.
	DatabaseName *string

	// The name of the partitions' table.
	//
	// This member is required.
	TableName *string

	// The ID of the Data Catalog where the partitions in question reside. If none is
	// supplied, the AWS account ID is used by default.
	CatalogId *string
}

type GetColumnStatisticsForTableOutput struct {

	// List of ColumnStatistics that failed to be retrieved.
	ColumnStatisticsList []types.ColumnStatistics

	// List of ColumnStatistics that failed to be retrieved.
	Errors []types.ColumnError

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetConnectionInput struct {

	// The name of the connection definition to retrieve.
	//
	// This member is required.
	Name *string

	// The ID of the Data Catalog in which the connection resides. If none is provided,
	// the AWS account ID is used by default.
	CatalogId *string

	// Allows you to retrieve the connection metadata without returning the password.
	// For instance, the AWS Glue console uses this flag to retrieve the connection,
	// and does not display the password. Set this parameter when the caller might not
	// have permission to use the AWS KMS key to decrypt the password, but it does have
	// permission to access the rest of the connection properties.
	HidePassword bool
}

type GetConnectionOutput struct {

	// The requested connection definition.
	Connection *types.Connection

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetConnectionsAPIClient interface {
	GetConnections(context.Context, *GetConnectionsInput, ...func(*Options)) (*GetConnectionsOutput, error)
}

type GetConnectionsInput struct {

	// The ID of the Data Catalog in which the connections reside. If none is provided,
	// the AWS account ID is used by default.
	CatalogId *string

	// A filter that controls which connections are returned.
	Filter *types.GetConnectionsFilter

	// Allows you to retrieve the connection metadata without returning the password.
	// For instance, the AWS Glue console uses this flag to retrieve the connection,
	// and does not display the password. Set this parameter when the caller might not
	// have permission to use the AWS KMS key to decrypt the password, but it does have
	// permission to access the rest of the connection properties.
	HidePassword bool

	// The maximum number of connections to return in one response.
	MaxResults *int32

	// A continuation token, if this is a continuation call.
	NextToken *string
}

type GetConnectionsOutput struct {

	// A list of requested connection definitions.
	ConnectionList []types.Connection

	// A continuation token, if the list of connections returned does not include the
	// last of the filtered connections.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetConnectionsPaginator struct {
	// contains filtered or unexported fields
}

type GetConnectionsPaginatorOptions struct {
	// The maximum number of connections to return in one response.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetCrawlerInput struct {

	// The name of the crawler to retrieve metadata for.
	//
	// This member is required.
	Name *string
}

type GetCrawlerMetricsAPIClient interface {
	GetCrawlerMetrics(context.Context, *GetCrawlerMetricsInput, ...func(*Options)) (*GetCrawlerMetricsOutput, error)
}

type GetCrawlerMetricsInput struct {

	// A list of the names of crawlers about which to retrieve metrics.
	CrawlerNameList []string

	// The maximum size of a list to return.
	MaxResults *int32

	// A continuation token, if this is a continuation call.
	NextToken *string
}

type GetCrawlerMetricsOutput struct {

	// A list of metrics for the specified crawler.
	CrawlerMetricsList []types.CrawlerMetrics

	// A continuation token, if the returned list does not contain the last metric
	// available.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetCrawlerMetricsPaginator struct {
	// contains filtered or unexported fields
}

type GetCrawlerMetricsPaginatorOptions struct {
	// The maximum size of a list to return.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetCrawlerOutput struct {

	// The metadata for the specified crawler.
	Crawler *types.Crawler

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetCrawlersAPIClient interface {
	GetCrawlers(context.Context, *GetCrawlersInput, ...func(*Options)) (*GetCrawlersOutput, error)
}

type GetCrawlersInput struct {

	// The number of crawlers to return on each call.
	MaxResults *int32

	// A continuation token, if this is a continuation request.
	NextToken *string
}

type GetCrawlersOutput struct {

	// A list of crawler metadata.
	Crawlers []types.Crawler

	// A continuation token, if the returned list has not reached the end of those
	// defined in this customer account.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetCrawlersPaginator struct {
	// contains filtered or unexported fields
}

type GetCrawlersPaginatorOptions struct {
	// The number of crawlers to return on each call.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetDataCatalogEncryptionSettingsInput struct {

	// The ID of the Data Catalog to retrieve the security configuration for. If none
	// is provided, the AWS account ID is used by default.
	CatalogId *string
}

type GetDataCatalogEncryptionSettingsOutput struct {

	// The requested security configuration.
	DataCatalogEncryptionSettings *types.DataCatalogEncryptionSettings

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetDatabaseInput struct {

	// The name of the database to retrieve. For Hive compatibility, this should be all
	// lowercase.
	//
	// This member is required.
	Name *string

	// The ID of the Data Catalog in which the database resides. If none is provided,
	// the AWS account ID is used by default.
	CatalogId *string
}

type GetDatabaseOutput struct {

	// The definition of the specified database in the Data Catalog.
	Database *types.Database

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetDatabasesAPIClient interface {
	GetDatabases(context.Context, *GetDatabasesInput, ...func(*Options)) (*GetDatabasesOutput, error)
}

type GetDatabasesInput struct {

	// The ID of the Data Catalog from which to retrieve Databases. If none is
	// provided, the AWS account ID is used by default.
	CatalogId *string

	// The maximum number of databases to return in one response.
	MaxResults *int32

	// A continuation token, if this is a continuation call.
	NextToken *string

	// Allows you to specify that you want to list the databases shared with your
	// account. The allowable values are FOREIGN or ALL.
	//
	// * If set to FOREIGN, will
	// list the databases shared with your account.
	//
	// * If set to ALL, will list the
	// databases shared with your account, as well as the databases in yor local
	// account.
	ResourceShareType types.ResourceShareType
}

type GetDatabasesOutput struct {

	// A list of Database objects from the specified catalog.
	//
	// This member is required.
	DatabaseList []types.Database

	// A continuation token for paginating the returned list of tokens, returned if the
	// current segment of the list is not the last.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetDatabasesPaginator struct {
	// contains filtered or unexported fields
}

type GetDatabasesPaginatorOptions struct {
	// The maximum number of databases to return in one response.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetDataflowGraphInput struct {

	// The Python script to transform.
	PythonScript *string
}

type GetDataflowGraphOutput struct {

	// A list of the edges in the resulting DAG.
	DagEdges []types.CodeGenEdge

	// A list of the nodes in the resulting DAG.
	DagNodes []types.CodeGenNode

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetDevEndpointInput struct {

	// Name of the DevEndpoint to retrieve information for.
	//
	// This member is required.
	EndpointName *string
}

type GetDevEndpointOutput struct {

	// A DevEndpoint definition.
	DevEndpoint *types.DevEndpoint

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetDevEndpointsAPIClient interface {
	GetDevEndpoints(context.Context, *GetDevEndpointsInput, ...func(*Options)) (*GetDevEndpointsOutput, error)
}

type GetDevEndpointsInput struct {

	// The maximum size of information to return.
	MaxResults *int32

	// A continuation token, if this is a continuation call.
	NextToken *string
}

type GetDevEndpointsOutput struct {

	// A list of DevEndpoint definitions.
	DevEndpoints []types.DevEndpoint

	// A continuation token, if not all DevEndpoint definitions have yet been returned.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetDevEndpointsPaginator struct {
	// contains filtered or unexported fields
}

type GetDevEndpointsPaginatorOptions struct {
	// The maximum size of information to return.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetJobBookmarkInput struct {

	// The name of the job in question.
	//
	// This member is required.
	JobName *string

	// The unique run identifier associated with this job run.
	RunId *string
}

type GetJobBookmarkOutput struct {

	// A structure that defines a point that a job can resume processing.
	JobBookmarkEntry *types.JobBookmarkEntry

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetJobInput struct {

	// The name of the job definition to retrieve.
	//
	// This member is required.
	JobName *string
}

type GetJobOutput struct {

	// The requested job definition.
	Job *types.Job

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetJobRunInput struct {

	// Name of the job definition being run.
	//
	// This member is required.
	JobName *string

	// The ID of the job run.
	//
	// This member is required.
	RunId *string

	// True if a list of predecessor runs should be returned.
	PredecessorsIncluded bool
}

type GetJobRunOutput struct {

	// The requested job-run metadata.
	JobRun *types.JobRun

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetJobRunsAPIClient interface {
	GetJobRuns(context.Context, *GetJobRunsInput, ...func(*Options)) (*GetJobRunsOutput, error)
}

type GetJobRunsInput struct {

	// The name of the job definition for which to retrieve all job runs.
	//
	// This member is required.
	JobName *string

	// The maximum size of the response.
	MaxResults *int32

	// A continuation token, if this is a continuation call.
	NextToken *string
}

type GetJobRunsOutput struct {

	// A list of job-run metadata objects.
	JobRuns []types.JobRun

	// A continuation token, if not all requested job runs have been returned.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetJobRunsPaginator struct {
	// contains filtered or unexported fields
}

type GetJobRunsPaginatorOptions struct {
	// The maximum size of the response.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetJobsAPIClient interface {
	GetJobs(context.Context, *GetJobsInput, ...func(*Options)) (*GetJobsOutput, error)
}

type GetJobsInput struct {

	// The maximum size of the response.
	MaxResults *int32

	// A continuation token, if this is a continuation call.
	NextToken *string
}

type GetJobsOutput struct {

	// A list of job definitions.
	Jobs []types.Job

	// A continuation token, if not all job definitions have yet been returned.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetJobsPaginator struct {
	// contains filtered or unexported fields
}

type GetJobsPaginatorOptions struct {
	// The maximum size of the response.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetMLTaskRunInput struct {

	// The unique identifier of the task run.
	//
	// This member is required.
	TaskRunId *string

	// The unique identifier of the machine learning transform.
	//
	// This member is required.
	TransformId *string
}

type GetMLTaskRunOutput struct {

	// The date and time when this task run was completed.
	CompletedOn *time.Time

	// The error strings that are associated with the task run.
	ErrorString *string

	// The amount of time (in seconds) that the task run consumed resources.
	ExecutionTime int32

	// The date and time when this task run was last modified.
	LastModifiedOn *time.Time

	// The names of the log groups that are associated with the task run.
	LogGroupName *string

	// The list of properties that are associated with the task run.
	Properties *types.TaskRunProperties

	// The date and time when this task run started.
	StartedOn *time.Time

	// The status for this task run.
	Status types.TaskStatusType

	// The unique run identifier associated with this run.
	TaskRunId *string

	// The unique identifier of the task run.
	TransformId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetMLTaskRunsAPIClient interface {
	GetMLTaskRuns(context.Context, *GetMLTaskRunsInput, ...func(*Options)) (*GetMLTaskRunsOutput, error)
}

type GetMLTaskRunsInput struct {

	// The unique identifier of the machine learning transform.
	//
	// This member is required.
	TransformId *string

	// The filter criteria, in the TaskRunFilterCriteria structure, for the task run.
	Filter *types.TaskRunFilterCriteria

	// The maximum number of results to return.
	MaxResults *int32

	// A token for pagination of the results. The default is empty.
	NextToken *string

	// The sorting criteria, in the TaskRunSortCriteria structure, for the task run.
	Sort *types.TaskRunSortCriteria
}

type GetMLTaskRunsOutput struct {

	// A pagination token, if more results are available.
	NextToken *string

	// A list of task runs that are associated with the transform.
	TaskRuns []types.TaskRun

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetMLTaskRunsPaginator struct {
	// contains filtered or unexported fields
}

type GetMLTaskRunsPaginatorOptions struct {
	// The maximum number of results to return.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetMLTransformInput struct {

	// The unique identifier of the transform, generated at the time that the transform
	// was created.
	//
	// This member is required.
	TransformId *string
}

type GetMLTransformOutput struct {

	// The date and time when the transform was created.
	CreatedOn *time.Time

	// A description of the transform.
	Description *string

	// The latest evaluation metrics.
	EvaluationMetrics *types.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 []types.GlueTable

	// The number of labels available for this transform.
	LabelCount int32

	// The date and time when the transform was last 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 (https://aws.amazon.com/glue/pricing/). 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 a task for this transform after a task run
	// fails.
	MaxRetries *int32

	// The unique name given to the transform when it was created.
	Name *string

	// The number of workers of a defined workerType that are allocated when this task
	// runs.
	NumberOfWorkers *int32

	// The configuration parameters that are specific to the algorithm used.
	Parameters *types.TransformParameters

	// The name or Amazon Resource Name (ARN) of the IAM role with the required
	// permissions.
	Role *string

	// The Map object that represents the schema that this transform accepts. Has an
	// upper bound of 100 columns.
	Schema []types.SchemaColumn

	// The last known status of the transform (to indicate whether it can be used or
	// not). One of "NOT_READY", "READY", or "DELETING".
	Status types.TransformStatusType

	// The timeout for a task run for this transform in minutes. This is the maximum
	// time that a task run for this transform can consume resources before it is
	// terminated and enters TIMEOUT status. The default is 2,880 minutes (48 hours).
	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 *types.TransformEncryption

	// The unique identifier of the transform, generated at the time that the transform
	// was created.
	TransformId *string

	// The type of predefined worker that is allocated when this task 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 types.WorkerType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetMLTransformsAPIClient interface {
	GetMLTransforms(context.Context, *GetMLTransformsInput, ...func(*Options)) (*GetMLTransformsOutput, error)
}

type GetMLTransformsInput struct {

	// The filter transformation criteria.
	Filter *types.TransformFilterCriteria

	// The maximum number of results to return.
	MaxResults *int32

	// A paginated token to offset the results.
	NextToken *string

	// The sorting criteria.
	Sort *types.TransformSortCriteria
}

type GetMLTransformsOutput struct {

	// A list of machine learning transforms.
	//
	// This member is required.
	Transforms []types.MLTransform

	// A pagination token, if more results are available.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetMLTransformsPaginator struct {
	// contains filtered or unexported fields
}

type GetMLTransformsPaginatorOptions struct {
	// The maximum number of results to return.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetMappingInput struct {

	// Specifies the source table.
	//
	// This member is required.
	Source *types.CatalogEntry

	// Parameters for the mapping.
	Location *types.Location

	// A list of target tables.
	Sinks []types.CatalogEntry
}

type GetMappingOutput struct {

	// A list of mappings to the specified targets.
	//
	// This member is required.
	Mapping []types.MappingEntry

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetPartitionIndexesAPIClient interface {
	GetPartitionIndexes(context.Context, *GetPartitionIndexesInput, ...func(*Options)) (*GetPartitionIndexesOutput, error)
}

type GetPartitionIndexesInput struct {

	// Specifies the name of a database from which you want to retrieve partition
	// indexes.
	//
	// This member is required.
	DatabaseName *string

	// Specifies the name of a table for which you want to retrieve the partition
	// indexes.
	//
	// This member is required.
	TableName *string

	// The catalog ID where the table resides.
	CatalogId *string

	// A continuation token, included if this is a continuation call.
	NextToken *string
}

type GetPartitionIndexesOutput struct {

	// A continuation token, present if the current list segment is not the last.
	NextToken *string

	// A list of index descriptors.
	PartitionIndexDescriptorList []types.PartitionIndexDescriptor

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetPartitionIndexesPaginator struct {
	// contains filtered or unexported fields
}

type GetPartitionIndexesPaginatorOptions struct {
	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetPartitionInput struct {

	// The name of the catalog database where the partition resides.
	//
	// This member is required.
	DatabaseName *string

	// The values that define the partition.
	//
	// This member is required.
	PartitionValues []string

	// The name of the partition's table.
	//
	// This member is required.
	TableName *string

	// The ID of the Data Catalog where the partition in question resides. If none is
	// provided, the AWS account ID is used by default.
	CatalogId *string
}

type GetPartitionOutput struct {

	// The requested information, in the form of a Partition object.
	Partition *types.Partition

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetPartitionsAPIClient interface {
	GetPartitions(context.Context, *GetPartitionsInput, ...func(*Options)) (*GetPartitionsOutput, error)
}

type GetPartitionsInput struct {

	// The name of the catalog database where the partitions reside.
	//
	// This member is required.
	DatabaseName *string

	// The name of the partitions' table.
	//
	// This member is required.
	TableName *string

	// The ID of the Data Catalog where the partitions in question reside. If none is
	// provided, the AWS account ID is used by default.
	CatalogId *string

	// An expression that filters the partitions to be returned. The expression uses
	// SQL syntax similar to the SQL WHERE filter clause. The SQL statement parser
	// JSQLParser (http://jsqlparser.sourceforge.net/home.php) parses the expression.
	// Operators: The following are the operators that you can use in the Expression
	// API call: = Checks whether the values of the two operands are equal; if yes,
	// then the condition becomes true. Example: Assume 'variable a' holds 10 and
	// 'variable b' holds 20. (a = b) is not true. < > Checks whether the values of two
	// operands are equal; if the values are not equal, then the condition becomes
	// true. Example: (a < > b) is true. > Checks whether the value of the left operand
	// is greater than the value of the right operand; if yes, then the condition
	// becomes true. Example: (a > b) is not true. < Checks whether the value of the
	// left operand is less than the value of the right operand; if yes, then the
	// condition becomes true. Example: (a < b) is true. >= Checks whether the value of
	// the left operand is greater than or equal to the value of the right operand; if
	// yes, then the condition becomes true. Example: (a >= b) is not true. <= Checks
	// whether the value of the left operand is less than or equal to the value of the
	// right operand; if yes, then the condition becomes true. Example: (a <= b) is
	// true. AND, OR, IN, BETWEEN, LIKE, NOT, IS NULL Logical operators. Supported
	// Partition Key Types: The following are the supported partition keys.
	//
	// *
	// string
	//
	// * date
	//
	// * timestamp
	//
	// * int
	//
	// * bigint
	//
	// * long
	//
	// * tinyint
	//
	// * smallint
	//
	// *
	// decimal
	//
	// If an invalid type is encountered, an exception is thrown. The
	// following list shows the valid operators on each type. When you define a
	// crawler, the partitionKey type is created as a STRING, to be compatible with the
	// catalog partitions. Sample API Call:
	Expression *string

	// The maximum number of partitions to return in a single response.
	MaxResults *int32

	// A continuation token, if this is not the first call to retrieve these
	// partitions.
	NextToken *string

	// The segment of the table's partitions to scan in this request.
	Segment *types.Segment
}

type GetPartitionsOutput struct {

	// A continuation token, if the returned list of partitions does not include the
	// last one.
	NextToken *string

	// A list of requested partitions.
	Partitions []types.Partition

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetPartitionsPaginator struct {
	// contains filtered or unexported fields
}

type GetPartitionsPaginatorOptions struct {
	// The maximum number of partitions to return in a single response.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetPlanInput struct {

	// The list of mappings from a source table to target tables.
	//
	// This member is required.
	Mapping []types.MappingEntry

	// The source table.
	//
	// This member is required.
	Source *types.CatalogEntry

	// A map to hold additional optional key-value parameters. Currently, these
	// key-value pairs are supported:
	//
	// * inferSchema — Specifies whether to set
	// inferSchema to true or false for the default script generated by an AWS Glue
	// job. For example, to set inferSchema to true, pass the following key value pair:
	// --additional-plan-options-map '{"inferSchema":"true"}'
	AdditionalPlanOptionsMap map[string]string

	// The programming language of the code to perform the mapping.
	Language types.Language

	// The parameters for the mapping.
	Location *types.Location

	// The target tables.
	Sinks []types.CatalogEntry
}

type GetPlanOutput struct {

	// A Python script to perform the mapping.
	PythonScript *string

	// The Scala code to perform the mapping.
	ScalaCode *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetRegistryInput struct {

	// This is a wrapper structure that may contain the registry name and Amazon
	// Resource Name (ARN).
	//
	// This member is required.
	RegistryId *types.RegistryId
}

type GetRegistryOutput struct {

	// The date and time the registry was created.
	CreatedTime *string

	// A description of the registry.
	Description *string

	// The Amazon Resource Name (ARN) of the registry.
	RegistryArn *string

	// The name of the registry.
	RegistryName *string

	// The status of the registry.
	Status types.RegistryStatus

	// The date and time the registry was updated.
	UpdatedTime *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetResourcePoliciesAPIClient interface {
	GetResourcePolicies(context.Context, *GetResourcePoliciesInput, ...func(*Options)) (*GetResourcePoliciesOutput, error)
}

type GetResourcePoliciesInput struct {

	// The maximum size of a list to return.
	MaxResults *int32

	// A continuation token, if this is a continuation request.
	NextToken *string
}

type GetResourcePoliciesOutput struct {

	// A list of the individual resource policies and the account-level resource
	// policy.
	GetResourcePoliciesResponseList []types.GluePolicy

	// A continuation token, if the returned list does not contain the last resource
	// policy available.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetResourcePoliciesPaginator struct {
	// contains filtered or unexported fields
}

type GetResourcePoliciesPaginatorOptions struct {
	// The maximum size of a list to return.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetResourcePolicyInput struct {

	// The ARN of the AWS Glue resource for the resource policy to be retrieved. For
	// more information about AWS Glue resource ARNs, see the AWS Glue ARN string
	// pattern
	// (https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-common.html#aws-glue-api-regex-aws-glue-arn-id)
	ResourceArn *string
}

type GetResourcePolicyOutput 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

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetSchemaByDefinitionInput struct {

	// The definition of the schema for which schema details are required.
	//
	// This member is required.
	SchemaDefinition *string

	// This is a wrapper structure to contain schema identity fields. The structure
	// contains:
	//
	// * SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema.
	// One of SchemaArn or SchemaName has to be provided.
	//
	// * SchemaId$SchemaName: The
	// name of the schema. One of SchemaArn or SchemaName has to be provided.
	//
	// This member is required.
	SchemaId *types.SchemaId
}

type GetSchemaByDefinitionOutput struct {

	// The date and time the schema was created.
	CreatedTime *string

	// The data format of the schema definition. Currently only AVRO is supported.
	DataFormat types.DataFormat

	// The Amazon Resource Name (ARN) of the schema.
	SchemaArn *string

	// The schema ID of the schema version.
	SchemaVersionId *string

	// The status of the schema version.
	Status types.SchemaVersionStatus

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetSchemaInput struct {

	// This is a wrapper structure to contain schema identity fields. The structure
	// contains:
	//
	// * SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema.
	// Either SchemaArn or SchemaName and RegistryName has to be provided.
	//
	// *
	// SchemaId$SchemaName: The name of the schema. Either SchemaArn or SchemaName and
	// RegistryName has to be provided.
	//
	// This member is required.
	SchemaId *types.SchemaId
}

type GetSchemaOutput struct {

	// The compatibility mode of the schema.
	Compatibility types.Compatibility

	// The date and time the schema was created.
	CreatedTime *string

	// The data format of the schema definition. Currently only AVRO is supported.
	DataFormat types.DataFormat

	// A description of schema if specified when created
	Description *string

	// The latest version of the schema associated with the returned schema definition.
	LatestSchemaVersion int64

	// The next version of the schema associated with the returned schema definition.
	NextSchemaVersion int64

	// The Amazon Resource Name (ARN) of the registry.
	RegistryArn *string

	// The name of the registry.
	RegistryName *string

	// The Amazon Resource Name (ARN) of the schema.
	SchemaArn *string

	// The version number of the checkpoint (the last time the compatibility mode was
	// changed).
	SchemaCheckpoint int64

	// The name of the schema.
	SchemaName *string

	// The status of the schema.
	SchemaStatus types.SchemaStatus

	// The date and time the schema was updated.
	UpdatedTime *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetSchemaVersionInput struct {

	// This is a wrapper structure to contain schema identity fields. The structure
	// contains:
	//
	// * SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema.
	// Either SchemaArn or SchemaName and RegistryName has to be provided.
	//
	// *
	// SchemaId$SchemaName: The name of the schema. Either SchemaArn or SchemaName and
	// RegistryName has to be provided.
	SchemaId *types.SchemaId

	// The SchemaVersionId of the schema version. This field is required for fetching
	// by schema ID. Either this or the SchemaId wrapper has to be provided.
	SchemaVersionId *string

	// The version number of the schema.
	SchemaVersionNumber *types.SchemaVersionNumber
}

type GetSchemaVersionOutput struct {

	// The date and time the schema version was created.
	CreatedTime *string

	// The data format of the schema definition. Currently only AVRO is supported.
	DataFormat types.DataFormat

	// The Amazon Resource Name (ARN) of the schema.
	SchemaArn *string

	// The schema definition for the schema ID.
	SchemaDefinition *string

	// The SchemaVersionId of the schema version.
	SchemaVersionId *string

	// The status of the schema version.
	Status types.SchemaVersionStatus

	// The version number of the schema.
	VersionNumber int64

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetSchemaVersionsDiffInput struct {

	// The first of the two schema versions to be compared.
	//
	// This member is required.
	FirstSchemaVersionNumber *types.SchemaVersionNumber

	// Refers to SYNTAX_DIFF, which is the currently supported diff type.
	//
	// This member is required.
	SchemaDiffType types.SchemaDiffType

	// This is a wrapper structure to contain schema identity fields. The structure
	// contains:
	//
	// * SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema.
	// One of SchemaArn or SchemaName has to be provided.
	//
	// * SchemaId$SchemaName: The
	// name of the schema. One of SchemaArn or SchemaName has to be provided.
	//
	// This member is required.
	SchemaId *types.SchemaId

	// The second of the two schema versions to be compared.
	//
	// This member is required.
	SecondSchemaVersionNumber *types.SchemaVersionNumber
}

type GetSchemaVersionsDiffOutput struct {

	// The difference between schemas as a string in JsonPatch format.
	Diff *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetSecurityConfigurationInput struct {

	// The name of the security configuration to retrieve.
	//
	// This member is required.
	Name *string
}

type GetSecurityConfigurationOutput struct {

	// The requested security configuration.
	SecurityConfiguration *types.SecurityConfiguration

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetSecurityConfigurationsAPIClient interface {
	GetSecurityConfigurations(context.Context, *GetSecurityConfigurationsInput, ...func(*Options)) (*GetSecurityConfigurationsOutput, error)
}

type GetSecurityConfigurationsInput struct {

	// The maximum number of results to return.
	MaxResults *int32

	// A continuation token, if this is a continuation call.
	NextToken *string
}

type GetSecurityConfigurationsOutput struct {

	// A continuation token, if there are more security configurations to return.
	NextToken *string

	// A list of security configurations.
	SecurityConfigurations []types.SecurityConfiguration

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetSecurityConfigurationsPaginator struct {
	// contains filtered or unexported fields
}

type GetSecurityConfigurationsPaginatorOptions struct {
	// The maximum number of results to return.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetTableInput struct {

	// The name of the database in the catalog in which the table resides. For Hive
	// compatibility, this name is entirely lowercase.
	//
	// This member is required.
	DatabaseName *string

	// The name of the table for which to retrieve the definition. For Hive
	// compatibility, this name is entirely lowercase.
	//
	// This member is required.
	Name *string

	// The ID of the Data Catalog where the table resides. If none is provided, the AWS
	// account ID is used by default.
	CatalogId *string
}

type GetTableOutput struct {

	// The Table object that defines the specified table.
	Table *types.Table

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetTableVersionInput struct {

	// The database in the catalog in which the table resides. For Hive compatibility,
	// this name is entirely lowercase.
	//
	// This member is required.
	DatabaseName *string

	// The name of the table. For Hive compatibility, this name is entirely lowercase.
	//
	// This member is required.
	TableName *string

	// The ID of the Data Catalog where the tables reside. If none is provided, the AWS
	// account ID is used by default.
	CatalogId *string

	// The ID value of the table version to be retrieved. A VersionID is a string
	// representation of an integer. Each version is incremented by 1.
	VersionId *string
}

type GetTableVersionOutput struct {

	// The requested table version.
	TableVersion *types.TableVersion

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetTableVersionsAPIClient interface {
	GetTableVersions(context.Context, *GetTableVersionsInput, ...func(*Options)) (*GetTableVersionsOutput, error)
}

type GetTableVersionsInput struct {

	// The database in the catalog in which the table resides. For Hive compatibility,
	// this name is entirely lowercase.
	//
	// This member is required.
	DatabaseName *string

	// The name of the table. For Hive compatibility, this name is entirely lowercase.
	//
	// This member is required.
	TableName *string

	// The ID of the Data Catalog where the tables reside. If none is provided, the AWS
	// account ID is used by default.
	CatalogId *string

	// The maximum number of table versions to return in one response.
	MaxResults *int32

	// A continuation token, if this is not the first call.
	NextToken *string
}

type GetTableVersionsOutput struct {

	// A continuation token, if the list of available versions does not include the
	// last one.
	NextToken *string

	// A list of strings identifying available versions of the specified table.
	TableVersions []types.TableVersion

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetTableVersionsPaginator struct {
	// contains filtered or unexported fields
}

type GetTableVersionsPaginatorOptions struct {
	// The maximum number of table versions to return in one response.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetTablesAPIClient interface {
	GetTables(context.Context, *GetTablesInput, ...func(*Options)) (*GetTablesOutput, error)
}

type GetTablesInput struct {

	// The database in the catalog whose tables to list. For Hive compatibility, this
	// name is entirely lowercase.
	//
	// This member is required.
	DatabaseName *string

	// The ID of the Data Catalog where the tables reside. If none is provided, the AWS
	// account ID is used by default.
	CatalogId *string

	// A regular expression pattern. If present, only those tables whose names match
	// the pattern are returned.
	Expression *string

	// The maximum number of tables to return in a single response.
	MaxResults *int32

	// A continuation token, included if this is a continuation call.
	NextToken *string
}

type GetTablesOutput struct {

	// A continuation token, present if the current list segment is not the last.
	NextToken *string

	// A list of the requested Table objects.
	TableList []types.Table

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetTablesPaginator struct {
	// contains filtered or unexported fields
}

type GetTablesPaginatorOptions struct {
	// The maximum number of tables to return in a single response.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetTagsInput struct {

	// The Amazon Resource Name (ARN) of the resource for which to retrieve tags.
	//
	// This member is required.
	ResourceArn *string
}

type GetTagsOutput struct {

	// The requested tags.
	Tags map[string]string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetTriggerInput struct {

	// The name of the trigger to retrieve.
	//
	// This member is required.
	Name *string
}

type GetTriggerOutput struct {

	// The requested trigger definition.
	Trigger *types.Trigger

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetTriggersAPIClient interface {
	GetTriggers(context.Context, *GetTriggersInput, ...func(*Options)) (*GetTriggersOutput, error)
}

type GetTriggersInput struct {

	// The name of the job to retrieve triggers for. The trigger that can start this
	// job is returned, and if there is no such trigger, all triggers are returned.
	DependentJobName *string

	// The maximum size of the response.
	MaxResults *int32

	// A continuation token, if this is a continuation call.
	NextToken *string
}

type GetTriggersOutput struct {

	// A continuation token, if not all the requested triggers have yet been returned.
	NextToken *string

	// A list of triggers for the specified job.
	Triggers []types.Trigger

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetTriggersPaginator struct {
	// contains filtered or unexported fields
}

type GetTriggersPaginatorOptions struct {
	// The maximum size of the response.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetUserDefinedFunctionInput struct {

	// The name of the catalog database where the function is located.
	//
	// This member is required.
	DatabaseName *string

	// The name of the function.
	//
	// This member is required.
	FunctionName *string

	// The ID of the Data Catalog where the function to be retrieved is located. If
	// none is provided, the AWS account ID is used by default.
	CatalogId *string
}

type GetUserDefinedFunctionOutput struct {

	// The requested function definition.
	UserDefinedFunction *types.UserDefinedFunction

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetUserDefinedFunctionsAPIClient interface {
	GetUserDefinedFunctions(context.Context, *GetUserDefinedFunctionsInput, ...func(*Options)) (*GetUserDefinedFunctionsOutput, error)
}

type GetUserDefinedFunctionsInput struct {

	// An optional function-name pattern string that filters the function definitions
	// returned.
	//
	// This member is required.
	Pattern *string

	// The ID of the Data Catalog where the functions to be retrieved are located. If
	// none is provided, the AWS account ID is used by default.
	CatalogId *string

	// The name of the catalog database where the functions are located. If none is
	// provided, functions from all the databases across the catalog will be returned.
	DatabaseName *string

	// The maximum number of functions to return in one response.
	MaxResults *int32

	// A continuation token, if this is a continuation call.
	NextToken *string
}

type GetUserDefinedFunctionsOutput struct {

	// A continuation token, if the list of functions returned does not include the
	// last requested function.
	NextToken *string

	// A list of requested function definitions.
	UserDefinedFunctions []types.UserDefinedFunction

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetUserDefinedFunctionsPaginator struct {
	// contains filtered or unexported fields
}

type GetUserDefinedFunctionsPaginatorOptions struct {
	// The maximum number of functions to return in one response.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetWorkflowInput struct {

	// The name of the workflow to retrieve.
	//
	// This member is required.
	Name *string

	// Specifies whether to include a graph when returning the workflow resource
	// metadata.
	IncludeGraph *bool
}

type GetWorkflowOutput struct {

	// The resource metadata for the workflow.
	Workflow *types.Workflow

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetWorkflowRunInput struct {

	// Name of the workflow being run.
	//
	// This member is required.
	Name *string

	// The ID of the workflow run.
	//
	// This member is required.
	RunId *string

	// Specifies whether to include the workflow graph in response or not.
	IncludeGraph *bool
}

type GetWorkflowRunOutput struct {

	// The requested workflow run metadata.
	Run *types.WorkflowRun

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetWorkflowRunPropertiesInput struct {

	// Name of the workflow which was run.
	//
	// This member is required.
	Name *string

	// The ID of the workflow run whose run properties should be returned.
	//
	// This member is required.
	RunId *string
}

type GetWorkflowRunPropertiesOutput struct {

	// The workflow run properties which were set during the specified run.
	RunProperties map[string]string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetWorkflowRunsAPIClient interface {
	GetWorkflowRuns(context.Context, *GetWorkflowRunsInput, ...func(*Options)) (*GetWorkflowRunsOutput, error)
}

type GetWorkflowRunsInput struct {

	// Name of the workflow whose metadata of runs should be returned.
	//
	// This member is required.
	Name *string

	// Specifies whether to include the workflow graph in response or not.
	IncludeGraph *bool

	// The maximum number of workflow runs to be included in the response.
	MaxResults *int32

	// The maximum size of the response.
	NextToken *string
}

type GetWorkflowRunsOutput struct {

	// A continuation token, if not all requested workflow runs have been returned.
	NextToken *string

	// A list of workflow run metadata objects.
	Runs []types.WorkflowRun

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetWorkflowRunsPaginator struct {
	// contains filtered or unexported fields
}