Documentation

Overview

    Package databrew provides the API client, operations, and parameter types for AWS Glue DataBrew.

    AWS Glue DataBrew is a visual, cloud-scale data-preparation service. DataBrew simplifies data preparation tasks, targeting data issues that are hard to spot and time-consuming to fix. DataBrew empowers users of all technical levels to visualize the data and perform one-click data transformations, with no coding required.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2017-07-25"
    View Source
    const ServiceID = "DataBrew"

    Variables

    This section is empty.

    Functions

    func NewDefaultEndpointResolver

    func NewDefaultEndpointResolver() *internalendpoints.Resolver

      NewDefaultEndpointResolver constructs a new service endpoint resolver

      func WithAPIOptions

      func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options)

        WithAPIOptions returns a functional option for setting the Client's APIOptions option.

        func WithEndpointResolver

        func WithEndpointResolver(v EndpointResolver) func(*Options)

          WithEndpointResolver returns a functional option for setting the Client's EndpointResolver option.

          Types

          type BatchDeleteRecipeVersionInput

          type BatchDeleteRecipeVersionInput struct {
          
          	// The name of the recipe to be modified.
          	//
          	// This member is required.
          	Name *string
          
          	// An array of version identifiers to be deleted.
          	//
          	// This member is required.
          	RecipeVersions []string
          }

          type BatchDeleteRecipeVersionOutput

          type BatchDeleteRecipeVersionOutput struct {
          
          	// The name of the recipe that was modified.
          	//
          	// This member is required.
          	Name *string
          
          	// Errors, if any, that were encountered when deleting the recipe versions.
          	Errors []types.RecipeVersionErrorDetail
          
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type Client

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

            Client provides the API client to make operations call for AWS Glue DataBrew.

            func New

            func New(options Options, optFns ...func(*Options)) *Client

              New returns an initialized Client based on the functional options. Provide additional functional options to further configure the behavior of the client, such as changing the client's endpoint or adding custom middleware behavior.

              func NewFromConfig

              func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client

                NewFromConfig returns a new client from the provided config.

                func (*Client) BatchDeleteRecipeVersion

                func (c *Client) BatchDeleteRecipeVersion(ctx context.Context, params *BatchDeleteRecipeVersionInput, optFns ...func(*Options)) (*BatchDeleteRecipeVersionOutput, error)

                  Deletes one or more versions of a recipe at a time.

                  func (*Client) CreateDataset

                  func (c *Client) CreateDataset(ctx context.Context, params *CreateDatasetInput, optFns ...func(*Options)) (*CreateDatasetOutput, error)

                    Creates a new AWS Glue DataBrew dataset for this AWS account.

                    func (*Client) CreateProfileJob

                    func (c *Client) CreateProfileJob(ctx context.Context, params *CreateProfileJobInput, optFns ...func(*Options)) (*CreateProfileJobOutput, error)

                      Creates a new job to profile an AWS Glue DataBrew dataset that exists in the current AWS account.

                      func (*Client) CreateProject

                      func (c *Client) CreateProject(ctx context.Context, params *CreateProjectInput, optFns ...func(*Options)) (*CreateProjectOutput, error)

                        Creates a new AWS Glue DataBrew project in the current AWS account.

                        func (*Client) CreateRecipe

                        func (c *Client) CreateRecipe(ctx context.Context, params *CreateRecipeInput, optFns ...func(*Options)) (*CreateRecipeOutput, error)

                          Creates a new AWS Glue DataBrew recipe for the current AWS account.

                          func (*Client) CreateRecipeJob

                          func (c *Client) CreateRecipeJob(ctx context.Context, params *CreateRecipeJobInput, optFns ...func(*Options)) (*CreateRecipeJobOutput, error)

                            Creates a new job for an existing AWS Glue DataBrew recipe in the current AWS account. You can create a standalone job using either a project, or a combination of a recipe and a dataset.

                            func (*Client) CreateSchedule

                            func (c *Client) CreateSchedule(ctx context.Context, params *CreateScheduleInput, optFns ...func(*Options)) (*CreateScheduleOutput, error)

                              Creates a new schedule for one or more AWS Glue DataBrew jobs. Jobs can be run at a specific date and time, or at regular intervals.

                              func (*Client) DeleteDataset

                              func (c *Client) DeleteDataset(ctx context.Context, params *DeleteDatasetInput, optFns ...func(*Options)) (*DeleteDatasetOutput, error)

                                Deletes a dataset from AWS Glue DataBrew.

                                func (*Client) DeleteJob

                                func (c *Client) DeleteJob(ctx context.Context, params *DeleteJobInput, optFns ...func(*Options)) (*DeleteJobOutput, error)

                                  Deletes the specified AWS Glue DataBrew job from the current AWS account. The job can be for a recipe or for a profile.

                                  func (*Client) DeleteProject

                                  func (c *Client) DeleteProject(ctx context.Context, params *DeleteProjectInput, optFns ...func(*Options)) (*DeleteProjectOutput, error)

                                    Deletes an existing AWS Glue DataBrew project from the current AWS account.

                                    func (*Client) DeleteRecipeVersion

                                    func (c *Client) DeleteRecipeVersion(ctx context.Context, params *DeleteRecipeVersionInput, optFns ...func(*Options)) (*DeleteRecipeVersionOutput, error)

                                      Deletes a single version of an AWS Glue DataBrew recipe.

                                      func (*Client) DeleteSchedule

                                      func (c *Client) DeleteSchedule(ctx context.Context, params *DeleteScheduleInput, optFns ...func(*Options)) (*DeleteScheduleOutput, error)

                                        Deletes the specified AWS Glue DataBrew schedule from the current AWS account.

                                        func (*Client) DescribeDataset

                                        func (c *Client) DescribeDataset(ctx context.Context, params *DescribeDatasetInput, optFns ...func(*Options)) (*DescribeDatasetOutput, error)

                                          Returns the definition of a specific AWS Glue DataBrew dataset that is in the current AWS account.

                                          func (*Client) DescribeJob

                                          func (c *Client) DescribeJob(ctx context.Context, params *DescribeJobInput, optFns ...func(*Options)) (*DescribeJobOutput, error)

                                            Returns the definition of a specific AWS Glue DataBrew job that is in the current AWS account.

                                            func (*Client) DescribeProject

                                            func (c *Client) DescribeProject(ctx context.Context, params *DescribeProjectInput, optFns ...func(*Options)) (*DescribeProjectOutput, error)

                                              Returns the definition of a specific AWS Glue DataBrew project that is in the current AWS account.

                                              func (*Client) DescribeRecipe

                                              func (c *Client) DescribeRecipe(ctx context.Context, params *DescribeRecipeInput, optFns ...func(*Options)) (*DescribeRecipeOutput, error)

                                                Returns the definition of a specific AWS Glue DataBrew recipe that is in the current AWS account.

                                                func (*Client) DescribeSchedule

                                                func (c *Client) DescribeSchedule(ctx context.Context, params *DescribeScheduleInput, optFns ...func(*Options)) (*DescribeScheduleOutput, error)

                                                  Returns the definition of a specific AWS Glue DataBrew schedule that is in the current AWS account.

                                                  func (*Client) ListDatasets

                                                  func (c *Client) ListDatasets(ctx context.Context, params *ListDatasetsInput, optFns ...func(*Options)) (*ListDatasetsOutput, error)

                                                    Lists all of the AWS Glue DataBrew datasets for the current AWS account.

                                                    func (*Client) ListJobRuns

                                                    func (c *Client) ListJobRuns(ctx context.Context, params *ListJobRunsInput, optFns ...func(*Options)) (*ListJobRunsOutput, error)

                                                      Lists all of the previous runs of a particular AWS Glue DataBrew job in the current AWS account.

                                                      func (*Client) ListJobs

                                                      func (c *Client) ListJobs(ctx context.Context, params *ListJobsInput, optFns ...func(*Options)) (*ListJobsOutput, error)

                                                        Lists the AWS Glue DataBrew jobs in the current AWS account.

                                                        func (*Client) ListProjects

                                                        func (c *Client) ListProjects(ctx context.Context, params *ListProjectsInput, optFns ...func(*Options)) (*ListProjectsOutput, error)

                                                          Lists all of the DataBrew projects in the current AWS account.

                                                          func (*Client) ListRecipeVersions

                                                          func (c *Client) ListRecipeVersions(ctx context.Context, params *ListRecipeVersionsInput, optFns ...func(*Options)) (*ListRecipeVersionsOutput, error)

                                                            Lists all of the versions of a particular AWS Glue DataBrew recipe in the current AWS account.

                                                            func (*Client) ListRecipes

                                                            func (c *Client) ListRecipes(ctx context.Context, params *ListRecipesInput, optFns ...func(*Options)) (*ListRecipesOutput, error)

                                                              Lists all of the AWS Glue DataBrew recipes in the current AWS account.

                                                              func (*Client) ListSchedules

                                                              func (c *Client) ListSchedules(ctx context.Context, params *ListSchedulesInput, optFns ...func(*Options)) (*ListSchedulesOutput, error)

                                                                Lists the AWS Glue DataBrew schedules in the current AWS account.

                                                                func (*Client) ListTagsForResource

                                                                func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error)

                                                                  Lists all the tags for an AWS Glue DataBrew resource.

                                                                  func (*Client) PublishRecipe

                                                                  func (c *Client) PublishRecipe(ctx context.Context, params *PublishRecipeInput, optFns ...func(*Options)) (*PublishRecipeOutput, error)

                                                                    Publishes a new major version of an AWS Glue DataBrew recipe that exists in the current AWS account.

                                                                    func (*Client) SendProjectSessionAction

                                                                    func (c *Client) SendProjectSessionAction(ctx context.Context, params *SendProjectSessionActionInput, optFns ...func(*Options)) (*SendProjectSessionActionOutput, error)

                                                                      Performs a recipe step within an interactive AWS Glue DataBrew session that's currently open.

                                                                      func (*Client) StartJobRun

                                                                      func (c *Client) StartJobRun(ctx context.Context, params *StartJobRunInput, optFns ...func(*Options)) (*StartJobRunOutput, error)

                                                                        Runs an AWS Glue DataBrew job that exists in the current AWS account.

                                                                        func (*Client) StartProjectSession

                                                                        func (c *Client) StartProjectSession(ctx context.Context, params *StartProjectSessionInput, optFns ...func(*Options)) (*StartProjectSessionOutput, error)

                                                                          Creates an interactive session, enabling you to manipulate an AWS Glue DataBrew project.

                                                                          func (*Client) StopJobRun

                                                                          func (c *Client) StopJobRun(ctx context.Context, params *StopJobRunInput, optFns ...func(*Options)) (*StopJobRunOutput, error)

                                                                            Stops the specified job from running in the current AWS account.

                                                                            func (*Client) TagResource

                                                                            func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error)

                                                                              Adds metadata tags to an AWS Glue DataBrew resource, such as a dataset, job, project, or recipe.

                                                                              func (*Client) UntagResource

                                                                              func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error)

                                                                                Removes metadata tags from an AWS Glue DataBrew resource.

                                                                                func (*Client) UpdateDataset

                                                                                func (c *Client) UpdateDataset(ctx context.Context, params *UpdateDatasetInput, optFns ...func(*Options)) (*UpdateDatasetOutput, error)

                                                                                  Modifies the definition of an existing AWS Glue DataBrew dataset in the current AWS account.

                                                                                  func (*Client) UpdateProfileJob

                                                                                  func (c *Client) UpdateProfileJob(ctx context.Context, params *UpdateProfileJobInput, optFns ...func(*Options)) (*UpdateProfileJobOutput, error)

                                                                                    Modifies the definition of an existing AWS Glue DataBrew job in the current AWS account.

                                                                                    func (*Client) UpdateProject

                                                                                    func (c *Client) UpdateProject(ctx context.Context, params *UpdateProjectInput, optFns ...func(*Options)) (*UpdateProjectOutput, error)

                                                                                      Modifies the definition of an existing AWS Glue DataBrew project in the current AWS account.

                                                                                      func (*Client) UpdateRecipe

                                                                                      func (c *Client) UpdateRecipe(ctx context.Context, params *UpdateRecipeInput, optFns ...func(*Options)) (*UpdateRecipeOutput, error)

                                                                                        Modifies the definition of the latest working version of an AWS Glue DataBrew recipe in the current AWS account.

                                                                                        func (*Client) UpdateRecipeJob

                                                                                        func (c *Client) UpdateRecipeJob(ctx context.Context, params *UpdateRecipeJobInput, optFns ...func(*Options)) (*UpdateRecipeJobOutput, error)

                                                                                          Modifies the definition of an existing AWS Glue DataBrew recipe job in the current AWS account.

                                                                                          func (*Client) UpdateSchedule

                                                                                          func (c *Client) UpdateSchedule(ctx context.Context, params *UpdateScheduleInput, optFns ...func(*Options)) (*UpdateScheduleOutput, error)

                                                                                            Modifies the definition of an existing AWS Glue DataBrew schedule in the current AWS account.

                                                                                            type CreateDatasetInput

                                                                                            type CreateDatasetInput struct {
                                                                                            
                                                                                            	// Information on how AWS Glue DataBrew can find data, in either the AWS Glue Data
                                                                                            	// Catalog or Amazon S3.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Input *types.Input
                                                                                            
                                                                                            	// The name of the dataset to be created.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// Options that define how Microsoft Excel input is to be interpreted by DataBrew.
                                                                                            	FormatOptions *types.FormatOptions
                                                                                            
                                                                                            	// Metadata tags to apply to this dataset.
                                                                                            	Tags map[string]string
                                                                                            }

                                                                                            type CreateDatasetOutput

                                                                                            type CreateDatasetOutput struct {
                                                                                            
                                                                                            	// The name of the dataset that you created.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type CreateProfileJobInput

                                                                                            type CreateProfileJobInput struct {
                                                                                            
                                                                                            	// The name of the dataset that this job is to act upon.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	DatasetName *string
                                                                                            
                                                                                            	// The name of the job to be created.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// An Amazon S3 location (bucket name an object key) where DataBrew can read input
                                                                                            	// data, or write output from a job.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	OutputLocation *types.S3Location
                                                                                            
                                                                                            	// The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM)
                                                                                            	// role to be assumed for this request.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	RoleArn *string
                                                                                            
                                                                                            	// The Amazon Resource Name (ARN) of an encryption key that is used to protect the
                                                                                            	// job.
                                                                                            	EncryptionKeyArn *string
                                                                                            
                                                                                            	// The encryption mode for the job, which can be one of the following:
                                                                                            	//
                                                                                            	// * SSE-KMS -
                                                                                            	// para>SSE-KMS - server-side encryption with AWS KMS-managed keys.
                                                                                            	//
                                                                                            	// * SSE-S3 -
                                                                                            	// Server-side encryption with keys managed by Amazon S3.
                                                                                            	EncryptionMode types.EncryptionMode
                                                                                            
                                                                                            	// A value that enables or disables Amazon CloudWatch logging for the current AWS
                                                                                            	// account. If logging is enabled, CloudWatch writes one log stream for each job
                                                                                            	// run.
                                                                                            	LogSubscription types.LogSubscription
                                                                                            
                                                                                            	// The maximum number of nodes that DataBrew can use when the job processes data.
                                                                                            	MaxCapacity int32
                                                                                            
                                                                                            	// The maximum number of times to retry the job after a job run fails.
                                                                                            	MaxRetries int32
                                                                                            
                                                                                            	// Metadata tags to apply to this job.
                                                                                            	Tags map[string]string
                                                                                            
                                                                                            	// The job's timeout in minutes. A job that attempts to run longer than this
                                                                                            	// timeout period ends with a status of TIMEOUT.
                                                                                            	Timeout int32
                                                                                            }

                                                                                            type CreateProfileJobOutput

                                                                                            type CreateProfileJobOutput struct {
                                                                                            
                                                                                            	// The name of the job that was created.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type CreateProjectInput

                                                                                            type CreateProjectInput struct {
                                                                                            
                                                                                            	// The name of the dataset to associate this project with.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	DatasetName *string
                                                                                            
                                                                                            	// A unique name for the new project.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// The name of an existing recipe to associate with the project.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	RecipeName *string
                                                                                            
                                                                                            	// The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM)
                                                                                            	// role to be assumed for this request.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	RoleArn *string
                                                                                            
                                                                                            	// Represents the sample size and sampling type for AWS Glue DataBrew to use for
                                                                                            	// interactive data analysis.
                                                                                            	Sample *types.Sample
                                                                                            
                                                                                            	// Metadata tags to apply to this project.
                                                                                            	Tags map[string]string
                                                                                            }

                                                                                            type CreateProjectOutput

                                                                                            type CreateProjectOutput struct {
                                                                                            
                                                                                            	// The name of the project that you created.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type CreateRecipeInput

                                                                                            type CreateRecipeInput struct {
                                                                                            
                                                                                            	// A unique name for the recipe.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// An array containing the steps to be performed by the recipe. Each recipe step
                                                                                            	// consists of one recipe action and (optionally) an array of condition
                                                                                            	// expressions.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Steps []types.RecipeStep
                                                                                            
                                                                                            	// A description for the recipe.
                                                                                            	Description *string
                                                                                            
                                                                                            	// Metadata tags to apply to this recipe.
                                                                                            	Tags map[string]string
                                                                                            }

                                                                                            type CreateRecipeJobInput

                                                                                            type CreateRecipeJobInput struct {
                                                                                            
                                                                                            	// A unique name for the job.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// One or more artifacts that represent the output from running the job.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Outputs []types.Output
                                                                                            
                                                                                            	// The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM)
                                                                                            	// role to be assumed for this request.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	RoleArn *string
                                                                                            
                                                                                            	// The name of the dataset that this job processes.
                                                                                            	DatasetName *string
                                                                                            
                                                                                            	// The Amazon Resource Name (ARN) of an encryption key that is used to protect the
                                                                                            	// job.
                                                                                            	EncryptionKeyArn *string
                                                                                            
                                                                                            	// The encryption mode for the job, which can be one of the following:
                                                                                            	//
                                                                                            	// * SSE-KMS -
                                                                                            	// Server-side encryption with AWS KMS-managed keys.
                                                                                            	//
                                                                                            	// * SSE-S3 - Server-side
                                                                                            	// encryption with keys managed by Amazon S3.
                                                                                            	EncryptionMode types.EncryptionMode
                                                                                            
                                                                                            	// A value that enables or disables Amazon CloudWatch logging for the current AWS
                                                                                            	// account. If logging is enabled, CloudWatch writes one log stream for each job
                                                                                            	// run.
                                                                                            	LogSubscription types.LogSubscription
                                                                                            
                                                                                            	// The maximum number of nodes that DataBrew can consume when the job processes
                                                                                            	// data.
                                                                                            	MaxCapacity int32
                                                                                            
                                                                                            	// The maximum number of times to retry the job after a job run fails.
                                                                                            	MaxRetries int32
                                                                                            
                                                                                            	// Either the name of an existing project, or a combination of a recipe and a
                                                                                            	// dataset to associate with the recipe.
                                                                                            	ProjectName *string
                                                                                            
                                                                                            	// Represents all of the attributes of an AWS Glue DataBrew recipe.
                                                                                            	RecipeReference *types.RecipeReference
                                                                                            
                                                                                            	// Metadata tags to apply to this job dataset.
                                                                                            	Tags map[string]string
                                                                                            
                                                                                            	// The job's timeout in minutes. A job that attempts to run longer than this
                                                                                            	// timeout period ends with a status of TIMEOUT.
                                                                                            	Timeout int32
                                                                                            }

                                                                                            type CreateRecipeJobOutput

                                                                                            type CreateRecipeJobOutput struct {
                                                                                            
                                                                                            	// The name of the job that you created.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type CreateRecipeOutput

                                                                                            type CreateRecipeOutput struct {
                                                                                            
                                                                                            	// The name of the recipe that you created.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type CreateScheduleInput

                                                                                            type CreateScheduleInput struct {
                                                                                            
                                                                                            	// The date or dates and time or times, in cron format, when the jobs are to be
                                                                                            	// run.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	CronExpression *string
                                                                                            
                                                                                            	// A unique name for the schedule.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// The name or names of one or more jobs to be run.
                                                                                            	JobNames []string
                                                                                            
                                                                                            	// Metadata tags to apply to this schedule.
                                                                                            	Tags map[string]string
                                                                                            }

                                                                                            type CreateScheduleOutput

                                                                                            type CreateScheduleOutput struct {
                                                                                            
                                                                                            	// The name of the schedule that was created.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DeleteDatasetInput

                                                                                            type DeleteDatasetInput struct {
                                                                                            
                                                                                            	// The name of the dataset to be deleted.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            }

                                                                                            type DeleteDatasetOutput

                                                                                            type DeleteDatasetOutput struct {
                                                                                            
                                                                                            	// The name of the dataset that you deleted.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DeleteJobInput

                                                                                            type DeleteJobInput struct {
                                                                                            
                                                                                            	// The name of the job to be deleted.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            }

                                                                                            type DeleteJobOutput

                                                                                            type DeleteJobOutput struct {
                                                                                            
                                                                                            	// The name of the job that you deleted.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DeleteProjectInput

                                                                                            type DeleteProjectInput struct {
                                                                                            
                                                                                            	// The name of the project to be deleted.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            }

                                                                                            type DeleteProjectOutput

                                                                                            type DeleteProjectOutput struct {
                                                                                            
                                                                                            	// The name of the project that you deleted.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DeleteRecipeVersionInput

                                                                                            type DeleteRecipeVersionInput struct {
                                                                                            
                                                                                            	// The name of the recipe to be deleted.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// The version of the recipe to be deleted.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	RecipeVersion *string
                                                                                            }

                                                                                            type DeleteRecipeVersionOutput

                                                                                            type DeleteRecipeVersionOutput struct {
                                                                                            
                                                                                            	// The name of the recipe that was deleted.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// The version of the recipe that was deleted.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	RecipeVersion *string
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DeleteScheduleInput

                                                                                            type DeleteScheduleInput struct {
                                                                                            
                                                                                            	// The name of the schedule to be deleted.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            }

                                                                                            type DeleteScheduleOutput

                                                                                            type DeleteScheduleOutput struct {
                                                                                            
                                                                                            	// The name of the schedule that was deleted.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DescribeDatasetInput

                                                                                            type DescribeDatasetInput struct {
                                                                                            
                                                                                            	// The name of the dataset to be described.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            }

                                                                                            type DescribeDatasetOutput

                                                                                            type DescribeDatasetOutput struct {
                                                                                            
                                                                                            	// Information on how AWS Glue DataBrew can find data, in either the AWS Glue Data
                                                                                            	// Catalog or Amazon S3.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Input *types.Input
                                                                                            
                                                                                            	// The name of the dataset.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// The date and time that the dataset was created.
                                                                                            	CreateDate *time.Time
                                                                                            
                                                                                            	// The identifier (user name) of the user who created the dataset.
                                                                                            	CreatedBy *string
                                                                                            
                                                                                            	// Options that define how Microsoft Excel input is to be interpreted by DataBrew.
                                                                                            	FormatOptions *types.FormatOptions
                                                                                            
                                                                                            	// The identifier (user name) of the user who last modified the dataset.
                                                                                            	LastModifiedBy *string
                                                                                            
                                                                                            	// The date and time that the dataset was last modified.
                                                                                            	LastModifiedDate *time.Time
                                                                                            
                                                                                            	// The Amazon Resource Name (ARN) of the dataset.
                                                                                            	ResourceArn *string
                                                                                            
                                                                                            	// The location of the data for this dataset, Amazon S3 or the AWS Glue Data
                                                                                            	// Catalog.
                                                                                            	Source types.Source
                                                                                            
                                                                                            	// Metadata tags associated with this dataset.
                                                                                            	Tags map[string]string
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DescribeJobInput

                                                                                            type DescribeJobInput struct {
                                                                                            
                                                                                            	// The name of the job to be described.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            }

                                                                                            type DescribeJobOutput

                                                                                            type DescribeJobOutput struct {
                                                                                            
                                                                                            	// The name of the job.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// The date and time that the job was created.
                                                                                            	CreateDate *time.Time
                                                                                            
                                                                                            	// The identifier (user name) of the user associated with the creation of the job.
                                                                                            	CreatedBy *string
                                                                                            
                                                                                            	// The dataset that the job acts upon.
                                                                                            	DatasetName *string
                                                                                            
                                                                                            	// The Amazon Resource Name (ARN) of an encryption key that is used to protect the
                                                                                            	// job.
                                                                                            	EncryptionKeyArn *string
                                                                                            
                                                                                            	// The encryption mode for the job, which can be one of the following:
                                                                                            	//
                                                                                            	// * SSE-KMS -
                                                                                            	// Server-side encryption with AWS KMS-managed keys.
                                                                                            	//
                                                                                            	// * SSE-S3 - Server-side
                                                                                            	// encryption with keys managed by Amazon S3.
                                                                                            	EncryptionMode types.EncryptionMode
                                                                                            
                                                                                            	// The identifier (user name) of the user who last modified the job.
                                                                                            	LastModifiedBy *string
                                                                                            
                                                                                            	// The date and time that the job was last modified.
                                                                                            	LastModifiedDate *time.Time
                                                                                            
                                                                                            	// A value that indicates whether Amazon CloudWatch logging is enabled for this
                                                                                            	// job.
                                                                                            	LogSubscription types.LogSubscription
                                                                                            
                                                                                            	// The maximum number of nodes that AWS Glue DataBrew can consume when the job
                                                                                            	// processes data.
                                                                                            	MaxCapacity int32
                                                                                            
                                                                                            	// The maximum number of times to retry the job after a job run fails.
                                                                                            	MaxRetries int32
                                                                                            
                                                                                            	// One or more artifacts that represent the output from running the job.
                                                                                            	Outputs []types.Output
                                                                                            
                                                                                            	// The DataBrew project associated with this job.
                                                                                            	ProjectName *string
                                                                                            
                                                                                            	// Represents all of the attributes of an AWS Glue DataBrew recipe.
                                                                                            	RecipeReference *types.RecipeReference
                                                                                            
                                                                                            	// The Amazon Resource Name (ARN) of the job.
                                                                                            	ResourceArn *string
                                                                                            
                                                                                            	// The ARN of the AWS Identity and Access Management (IAM) role that was assumed
                                                                                            	// for this request.
                                                                                            	RoleArn *string
                                                                                            
                                                                                            	// Metadata tags associated with this job.
                                                                                            	Tags map[string]string
                                                                                            
                                                                                            	// The job's timeout in minutes. A job that attempts to run longer than this
                                                                                            	// timeout period ends with a status of TIMEOUT.
                                                                                            	Timeout int32
                                                                                            
                                                                                            	// The job type, which must be one of the following:
                                                                                            	//
                                                                                            	// * PROFILE - The job analyzes
                                                                                            	// the dataset to determine its size, data types, data distribution, and more.
                                                                                            	//
                                                                                            	// *
                                                                                            	// RECIPE - The job applies one or more transformations to a dataset.
                                                                                            	Type types.JobType
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DescribeProjectInput

                                                                                            type DescribeProjectInput struct {
                                                                                            
                                                                                            	// The name of the project to be described.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            }

                                                                                            type DescribeProjectOutput

                                                                                            type DescribeProjectOutput struct {
                                                                                            
                                                                                            	// The name of the project.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// The date and time that the project was created.
                                                                                            	CreateDate *time.Time
                                                                                            
                                                                                            	// The identifier (user name) of the user who created the project.
                                                                                            	CreatedBy *string
                                                                                            
                                                                                            	// The dataset associated with the project.
                                                                                            	DatasetName *string
                                                                                            
                                                                                            	// The identifier (user name) of the user who last modified the project.
                                                                                            	LastModifiedBy *string
                                                                                            
                                                                                            	// The date and time that the project was last modified.
                                                                                            	LastModifiedDate *time.Time
                                                                                            
                                                                                            	// The date and time when the project was opened.
                                                                                            	OpenDate *time.Time
                                                                                            
                                                                                            	// The identifier (user name) of the user that opened the project for use.
                                                                                            	OpenedBy *string
                                                                                            
                                                                                            	// The recipe associated with this job.
                                                                                            	RecipeName *string
                                                                                            
                                                                                            	// The Amazon Resource Name (ARN) of the project.
                                                                                            	ResourceArn *string
                                                                                            
                                                                                            	// The ARN of the AWS Identity and Access Management (IAM) role that was assumed
                                                                                            	// for this request.
                                                                                            	RoleArn *string
                                                                                            
                                                                                            	// Represents the sample size and sampling type for AWS Glue DataBrew to use for
                                                                                            	// interactive data analysis.
                                                                                            	Sample *types.Sample
                                                                                            
                                                                                            	// Describes the current state of the session:
                                                                                            	//
                                                                                            	// * PROVISIONING - allocating
                                                                                            	// resources for the session.
                                                                                            	//
                                                                                            	// * INITIALIZING - getting the session ready for first
                                                                                            	// use.
                                                                                            	//
                                                                                            	// * ASSIGNED - the session is ready for use.
                                                                                            	SessionStatus types.SessionStatus
                                                                                            
                                                                                            	// Metadata tags associated with this project.
                                                                                            	Tags map[string]string
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DescribeRecipeInput

                                                                                            type DescribeRecipeInput struct {
                                                                                            
                                                                                            	// The name of the recipe to be described.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// The recipe version identifier. If this parameter isn't specified, then the
                                                                                            	// latest published version is returned.
                                                                                            	RecipeVersion *string
                                                                                            }

                                                                                            type DescribeRecipeOutput

                                                                                            type DescribeRecipeOutput struct {
                                                                                            
                                                                                            	// The name of the recipe.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// The date and time that the recipe was created.
                                                                                            	CreateDate *time.Time
                                                                                            
                                                                                            	// The identifier (user name) of the user who created the recipe.
                                                                                            	CreatedBy *string
                                                                                            
                                                                                            	// The description of the recipe.
                                                                                            	Description *string
                                                                                            
                                                                                            	// The identifier (user name) of the user who last modified the recipe.
                                                                                            	LastModifiedBy *string
                                                                                            
                                                                                            	// The date and time that the recipe was last modified.
                                                                                            	LastModifiedDate *time.Time
                                                                                            
                                                                                            	// The name of the project associated with this recipe.
                                                                                            	ProjectName *string
                                                                                            
                                                                                            	// The identifier (user name) of the user who last published the recipe.
                                                                                            	PublishedBy *string
                                                                                            
                                                                                            	// The date and time when the recipe was last published.
                                                                                            	PublishedDate *time.Time
                                                                                            
                                                                                            	// The recipe version identifier.
                                                                                            	RecipeVersion *string
                                                                                            
                                                                                            	// The ARN of the recipe.
                                                                                            	ResourceArn *string
                                                                                            
                                                                                            	// One or more steps to be performed by the recipe. Each step consists of an
                                                                                            	// action, and the conditions under which the action should succeed.
                                                                                            	Steps []types.RecipeStep
                                                                                            
                                                                                            	// Metadata tags associated with this project.
                                                                                            	Tags map[string]string
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type DescribeScheduleInput

                                                                                            type DescribeScheduleInput struct {
                                                                                            
                                                                                            	// The name of the schedule to be described.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            }

                                                                                            type DescribeScheduleOutput

                                                                                            type DescribeScheduleOutput struct {
                                                                                            
                                                                                            	// The name of the schedule.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	Name *string
                                                                                            
                                                                                            	// The date and time that the schedule was created.
                                                                                            	CreateDate *time.Time
                                                                                            
                                                                                            	// The identifier (user name) of the user who created the schedule.
                                                                                            	CreatedBy *string
                                                                                            
                                                                                            	// The date or dates and time or times, in cron format, when the jobs are to be run
                                                                                            	// for the schedule.
                                                                                            	CronExpression *string
                                                                                            
                                                                                            	// The name or names of one or more jobs to be run by using the schedule.
                                                                                            	JobNames []string
                                                                                            
                                                                                            	// The identifier (user name) of the user who last modified the schedule.
                                                                                            	LastModifiedBy *string
                                                                                            
                                                                                            	// The date and time that the schedule was last modified.
                                                                                            	LastModifiedDate *time.Time
                                                                                            
                                                                                            	// The Amazon Resource Name (ARN) of the schedule.
                                                                                            	ResourceArn *string
                                                                                            
                                                                                            	// Metadata tags associated with this schedule.
                                                                                            	Tags map[string]string
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type EndpointResolver

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

                                                                                              EndpointResolver interface for resolving service endpoints.

                                                                                              func EndpointResolverFromURL

                                                                                              func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver

                                                                                                EndpointResolverFromURL returns an EndpointResolver configured using the provided endpoint url. By default, the resolved endpoint resolver uses the client region as signing region, and the endpoint source is set to EndpointSourceCustom.You can provide functional options to configure endpoint values for the resolved endpoint.

                                                                                                type EndpointResolverFunc

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

                                                                                                  EndpointResolverFunc is a helper utility that wraps a function so it satisfies the EndpointResolver interface. This is useful when you want to add additional endpoint resolving logic, or stub out specific endpoints with custom values.

                                                                                                  func (EndpointResolverFunc) ResolveEndpoint

                                                                                                  func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error)

                                                                                                  type EndpointResolverOptions

                                                                                                  type EndpointResolverOptions = internalendpoints.Options

                                                                                                    EndpointResolverOptions is the service endpoint resolver options

                                                                                                    type HTTPClient

                                                                                                    type HTTPClient interface {
                                                                                                    	Do(*http.Request) (*http.Response, error)
                                                                                                    }

                                                                                                    type HTTPSignerV4

                                                                                                    type HTTPSignerV4 interface {
                                                                                                    	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
                                                                                                    }

                                                                                                    type ListDatasetsAPIClient

                                                                                                    type ListDatasetsAPIClient interface {
                                                                                                    	ListDatasets(context.Context, *ListDatasetsInput, ...func(*Options)) (*ListDatasetsOutput, error)
                                                                                                    }

                                                                                                      ListDatasetsAPIClient is a client that implements the ListDatasets operation.

                                                                                                      type ListDatasetsInput

                                                                                                      type ListDatasetsInput struct {
                                                                                                      
                                                                                                      	// The maximum number of results to return in this request.
                                                                                                      	MaxResults *int32
                                                                                                      
                                                                                                      	// A token generated by DataBrew that specifies where to continue pagination if a
                                                                                                      	// previous request was truncated. To get the next set of pages, pass in the
                                                                                                      	// NextToken value from the response object of the previous page call.
                                                                                                      	NextToken *string
                                                                                                      }

                                                                                                      type ListDatasetsOutput

                                                                                                      type ListDatasetsOutput struct {
                                                                                                      
                                                                                                      	// A list of datasets that are defined in the current AWS account.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	Datasets []types.Dataset
                                                                                                      
                                                                                                      	// A token generated by DataBrew that specifies where to continue pagination if a
                                                                                                      	// previous request was truncated. To obtain the next set of pages, pass in the
                                                                                                      	// NextToken from the response object of the previous page call.
                                                                                                      	NextToken *string
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type ListDatasetsPaginator

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

                                                                                                        ListDatasetsPaginator is a paginator for ListDatasets

                                                                                                        func NewListDatasetsPaginator

                                                                                                        func NewListDatasetsPaginator(client ListDatasetsAPIClient, params *ListDatasetsInput, optFns ...func(*ListDatasetsPaginatorOptions)) *ListDatasetsPaginator

                                                                                                          NewListDatasetsPaginator returns a new ListDatasetsPaginator

                                                                                                          func (*ListDatasetsPaginator) HasMorePages

                                                                                                          func (p *ListDatasetsPaginator) HasMorePages() bool

                                                                                                            HasMorePages returns a boolean indicating whether more pages are available

                                                                                                            func (*ListDatasetsPaginator) NextPage

                                                                                                            func (p *ListDatasetsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDatasetsOutput, error)

                                                                                                              NextPage retrieves the next ListDatasets page.

                                                                                                              type ListDatasetsPaginatorOptions

                                                                                                              type ListDatasetsPaginatorOptions struct {
                                                                                                              	// The maximum number of results to return in this request.
                                                                                                              	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
                                                                                                              }

                                                                                                                ListDatasetsPaginatorOptions is the paginator options for ListDatasets

                                                                                                                type ListJobRunsAPIClient

                                                                                                                type ListJobRunsAPIClient interface {
                                                                                                                	ListJobRuns(context.Context, *ListJobRunsInput, ...func(*Options)) (*ListJobRunsOutput, error)
                                                                                                                }

                                                                                                                  ListJobRunsAPIClient is a client that implements the ListJobRuns operation.

                                                                                                                  type ListJobRunsInput

                                                                                                                  type ListJobRunsInput struct {
                                                                                                                  
                                                                                                                  	// The name of the job.
                                                                                                                  	//
                                                                                                                  	// This member is required.
                                                                                                                  	Name *string
                                                                                                                  
                                                                                                                  	// The maximum number of results to return in this request.
                                                                                                                  	MaxResults *int32
                                                                                                                  
                                                                                                                  	// A token generated by AWS Glue DataBrew that specifies where to continue
                                                                                                                  	// pagination if a previous request was truncated. To get the next set of pages,
                                                                                                                  	// pass in the NextToken value from the response object of the previous page call.
                                                                                                                  	NextToken *string
                                                                                                                  }

                                                                                                                  type ListJobRunsOutput

                                                                                                                  type ListJobRunsOutput struct {
                                                                                                                  
                                                                                                                  	// A list of job runs that have occurred for the specified job.
                                                                                                                  	//
                                                                                                                  	// This member is required.
                                                                                                                  	JobRuns []types.JobRun
                                                                                                                  
                                                                                                                  	// A token generated by DataBrew that specifies where to continue pagination if a
                                                                                                                  	// previous request was truncated. To obtain the next set of pages, pass in the
                                                                                                                  	// NextToken from the response object of the previous page call.
                                                                                                                  	NextToken *string
                                                                                                                  
                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                  }

                                                                                                                  type ListJobRunsPaginator

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

                                                                                                                    ListJobRunsPaginator is a paginator for ListJobRuns

                                                                                                                    func NewListJobRunsPaginator

                                                                                                                    func NewListJobRunsPaginator(client ListJobRunsAPIClient, params *ListJobRunsInput, optFns ...func(*ListJobRunsPaginatorOptions)) *ListJobRunsPaginator

                                                                                                                      NewListJobRunsPaginator returns a new ListJobRunsPaginator

                                                                                                                      func (*ListJobRunsPaginator) HasMorePages

                                                                                                                      func (p *ListJobRunsPaginator) HasMorePages() bool

                                                                                                                        HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                        func (*ListJobRunsPaginator) NextPage

                                                                                                                        func (p *ListJobRunsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListJobRunsOutput, error)

                                                                                                                          NextPage retrieves the next ListJobRuns page.

                                                                                                                          type ListJobRunsPaginatorOptions

                                                                                                                          type ListJobRunsPaginatorOptions struct {
                                                                                                                          	// The maximum number of results to return in this request.
                                                                                                                          	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
                                                                                                                          }

                                                                                                                            ListJobRunsPaginatorOptions is the paginator options for ListJobRuns

                                                                                                                            type ListJobsAPIClient

                                                                                                                            type ListJobsAPIClient interface {
                                                                                                                            	ListJobs(context.Context, *ListJobsInput, ...func(*Options)) (*ListJobsOutput, error)
                                                                                                                            }

                                                                                                                              ListJobsAPIClient is a client that implements the ListJobs operation.

                                                                                                                              type ListJobsInput

                                                                                                                              type ListJobsInput struct {
                                                                                                                              
                                                                                                                              	// The name of a dataset. Using this parameter indicates to return only those jobs
                                                                                                                              	// that act on the specified dataset.
                                                                                                                              	DatasetName *string
                                                                                                                              
                                                                                                                              	// The maximum number of results to return in this request.
                                                                                                                              	MaxResults *int32
                                                                                                                              
                                                                                                                              	// A token generated by DataBrew that specifies where to continue pagination if a
                                                                                                                              	// previous request was truncated. To get the next set of pages, pass in the
                                                                                                                              	// NextToken value from the response object of the previous page call.
                                                                                                                              	NextToken *string
                                                                                                                              
                                                                                                                              	// The name of a project. Using this parameter indicates to return only those jobs
                                                                                                                              	// that are associated with the specified project.
                                                                                                                              	ProjectName *string
                                                                                                                              }

                                                                                                                              type ListJobsOutput

                                                                                                                              type ListJobsOutput struct {
                                                                                                                              
                                                                                                                              	// A list of jobs that are defined in the current AWS account.
                                                                                                                              	//
                                                                                                                              	// This member is required.
                                                                                                                              	Jobs []types.Job
                                                                                                                              
                                                                                                                              	// A token generated by DataBrew that specifies where to continue pagination if a
                                                                                                                              	// previous request was truncated. To obtain the next set of pages, pass in the
                                                                                                                              	// NextToken from the response object of the previous page call.
                                                                                                                              	NextToken *string
                                                                                                                              
                                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                                              }

                                                                                                                              type ListJobsPaginator

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

                                                                                                                                ListJobsPaginator is a paginator for ListJobs

                                                                                                                                func NewListJobsPaginator

                                                                                                                                func NewListJobsPaginator(client ListJobsAPIClient, params *ListJobsInput, optFns ...func(*ListJobsPaginatorOptions)) *ListJobsPaginator

                                                                                                                                  NewListJobsPaginator returns a new ListJobsPaginator

                                                                                                                                  func (*ListJobsPaginator) HasMorePages

                                                                                                                                  func (p *ListJobsPaginator) HasMorePages() bool

                                                                                                                                    HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                    func (*ListJobsPaginator) NextPage

                                                                                                                                    func (p *ListJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListJobsOutput, error)

                                                                                                                                      NextPage retrieves the next ListJobs page.

                                                                                                                                      type ListJobsPaginatorOptions

                                                                                                                                      type ListJobsPaginatorOptions struct {
                                                                                                                                      	// The maximum number of results to return in this request.
                                                                                                                                      	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
                                                                                                                                      }

                                                                                                                                        ListJobsPaginatorOptions is the paginator options for ListJobs

                                                                                                                                        type ListProjectsAPIClient

                                                                                                                                        type ListProjectsAPIClient interface {
                                                                                                                                        	ListProjects(context.Context, *ListProjectsInput, ...func(*Options)) (*ListProjectsOutput, error)
                                                                                                                                        }

                                                                                                                                          ListProjectsAPIClient is a client that implements the ListProjects operation.

                                                                                                                                          type ListProjectsInput

                                                                                                                                          type ListProjectsInput struct {
                                                                                                                                          
                                                                                                                                          	// The maximum number of results to return in this request.
                                                                                                                                          	MaxResults *int32
                                                                                                                                          
                                                                                                                                          	// A pagination token that can be used in a subsequent request.
                                                                                                                                          	NextToken *string
                                                                                                                                          }

                                                                                                                                          type ListProjectsOutput

                                                                                                                                          type ListProjectsOutput struct {
                                                                                                                                          
                                                                                                                                          	// A list of projects that are defined in the current AWS account.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	Projects []types.Project
                                                                                                                                          
                                                                                                                                          	// A token generated by DataBrew that specifies where to continue pagination if a
                                                                                                                                          	// previous request was truncated. To get the next set of pages, pass in the
                                                                                                                                          	// NextToken value from the response object of the previous page call.
                                                                                                                                          	NextToken *string
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type ListProjectsPaginator

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

                                                                                                                                            ListProjectsPaginator is a paginator for ListProjects

                                                                                                                                            func NewListProjectsPaginator

                                                                                                                                            func NewListProjectsPaginator(client ListProjectsAPIClient, params *ListProjectsInput, optFns ...func(*ListProjectsPaginatorOptions)) *ListProjectsPaginator

                                                                                                                                              NewListProjectsPaginator returns a new ListProjectsPaginator

                                                                                                                                              func (*ListProjectsPaginator) HasMorePages

                                                                                                                                              func (p *ListProjectsPaginator) HasMorePages() bool

                                                                                                                                                HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                func (*ListProjectsPaginator) NextPage

                                                                                                                                                func (p *ListProjectsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListProjectsOutput, error)

                                                                                                                                                  NextPage retrieves the next ListProjects page.

                                                                                                                                                  type ListProjectsPaginatorOptions

                                                                                                                                                  type ListProjectsPaginatorOptions struct {
                                                                                                                                                  	// The maximum number of results to return in this request.
                                                                                                                                                  	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
                                                                                                                                                  }

                                                                                                                                                    ListProjectsPaginatorOptions is the paginator options for ListProjects

                                                                                                                                                    type ListRecipeVersionsAPIClient

                                                                                                                                                    type ListRecipeVersionsAPIClient interface {
                                                                                                                                                    	ListRecipeVersions(context.Context, *ListRecipeVersionsInput, ...func(*Options)) (*ListRecipeVersionsOutput, error)
                                                                                                                                                    }

                                                                                                                                                      ListRecipeVersionsAPIClient is a client that implements the ListRecipeVersions operation.

                                                                                                                                                      type ListRecipeVersionsInput

                                                                                                                                                      type ListRecipeVersionsInput struct {
                                                                                                                                                      
                                                                                                                                                      	// The name of the recipe for which to return version information.
                                                                                                                                                      	//
                                                                                                                                                      	// This member is required.
                                                                                                                                                      	Name *string
                                                                                                                                                      
                                                                                                                                                      	// The maximum number of results to return in this request.
                                                                                                                                                      	MaxResults *int32
                                                                                                                                                      
                                                                                                                                                      	// A pagination token that can be used in a subsequent request.
                                                                                                                                                      	NextToken *string
                                                                                                                                                      }

                                                                                                                                                      type ListRecipeVersionsOutput

                                                                                                                                                      type ListRecipeVersionsOutput struct {
                                                                                                                                                      
                                                                                                                                                      	// A list of versions for the specified recipe.
                                                                                                                                                      	//
                                                                                                                                                      	// This member is required.
                                                                                                                                                      	Recipes []types.Recipe
                                                                                                                                                      
                                                                                                                                                      	// A token generated by DataBrew that specifies where to continue pagination if a
                                                                                                                                                      	// previous request was truncated. To get the next set of pages, pass in the
                                                                                                                                                      	// NextToken value from the response object of the previous page call.
                                                                                                                                                      	NextToken *string
                                                                                                                                                      
                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                      }

                                                                                                                                                      type ListRecipeVersionsPaginator

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

                                                                                                                                                        ListRecipeVersionsPaginator is a paginator for ListRecipeVersions

                                                                                                                                                        func NewListRecipeVersionsPaginator

                                                                                                                                                        func NewListRecipeVersionsPaginator(client ListRecipeVersionsAPIClient, params *ListRecipeVersionsInput, optFns ...func(*ListRecipeVersionsPaginatorOptions)) *ListRecipeVersionsPaginator

                                                                                                                                                          NewListRecipeVersionsPaginator returns a new ListRecipeVersionsPaginator

                                                                                                                                                          func (*ListRecipeVersionsPaginator) HasMorePages

                                                                                                                                                          func (p *ListRecipeVersionsPaginator) HasMorePages() bool

                                                                                                                                                            HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                            func (*ListRecipeVersionsPaginator) NextPage

                                                                                                                                                            func (p *ListRecipeVersionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListRecipeVersionsOutput, error)

                                                                                                                                                              NextPage retrieves the next ListRecipeVersions page.

                                                                                                                                                              type ListRecipeVersionsPaginatorOptions

                                                                                                                                                              type ListRecipeVersionsPaginatorOptions struct {
                                                                                                                                                              	// The maximum number of results to return in this request.
                                                                                                                                                              	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
                                                                                                                                                              }

                                                                                                                                                                ListRecipeVersionsPaginatorOptions is the paginator options for ListRecipeVersions

                                                                                                                                                                type ListRecipesAPIClient

                                                                                                                                                                type ListRecipesAPIClient interface {
                                                                                                                                                                	ListRecipes(context.Context, *ListRecipesInput, ...func(*Options)) (*ListRecipesOutput, error)
                                                                                                                                                                }

                                                                                                                                                                  ListRecipesAPIClient is a client that implements the ListRecipes operation.

                                                                                                                                                                  type ListRecipesInput

                                                                                                                                                                  type ListRecipesInput struct {
                                                                                                                                                                  
                                                                                                                                                                  	// The maximum number of results to return in this request.
                                                                                                                                                                  	MaxResults *int32
                                                                                                                                                                  
                                                                                                                                                                  	// A pagination token that can be used in a subsequent request.
                                                                                                                                                                  	NextToken *string
                                                                                                                                                                  
                                                                                                                                                                  	// A version identifier. Using this parameter indicates to return only those
                                                                                                                                                                  	// recipes that have this version identifier.
                                                                                                                                                                  	RecipeVersion *string
                                                                                                                                                                  }

                                                                                                                                                                  type ListRecipesOutput

                                                                                                                                                                  type ListRecipesOutput struct {
                                                                                                                                                                  
                                                                                                                                                                  	// A list of recipes that are defined in the current AWS account.
                                                                                                                                                                  	//
                                                                                                                                                                  	// This member is required.
                                                                                                                                                                  	Recipes []types.Recipe
                                                                                                                                                                  
                                                                                                                                                                  	// A token generated by DataBrew that specifies where to continue pagination if a
                                                                                                                                                                  	// previous request was truncated. To get the next set of pages, pass in the
                                                                                                                                                                  	// NextToken value from the response object of the previous page call.
                                                                                                                                                                  	NextToken *string
                                                                                                                                                                  
                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                  }

                                                                                                                                                                  type ListRecipesPaginator

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

                                                                                                                                                                    ListRecipesPaginator is a paginator for ListRecipes

                                                                                                                                                                    func NewListRecipesPaginator

                                                                                                                                                                    func NewListRecipesPaginator(client ListRecipesAPIClient, params *ListRecipesInput, optFns ...func(*ListRecipesPaginatorOptions)) *ListRecipesPaginator

                                                                                                                                                                      NewListRecipesPaginator returns a new ListRecipesPaginator

                                                                                                                                                                      func (*ListRecipesPaginator) HasMorePages

                                                                                                                                                                      func (p *ListRecipesPaginator) HasMorePages() bool

                                                                                                                                                                        HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                        func (*ListRecipesPaginator) NextPage

                                                                                                                                                                        func (p *ListRecipesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListRecipesOutput, error)

                                                                                                                                                                          NextPage retrieves the next ListRecipes page.

                                                                                                                                                                          type ListRecipesPaginatorOptions

                                                                                                                                                                          type ListRecipesPaginatorOptions struct {
                                                                                                                                                                          	// The maximum number of results to return in this request.
                                                                                                                                                                          	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
                                                                                                                                                                          }

                                                                                                                                                                            ListRecipesPaginatorOptions is the paginator options for ListRecipes

                                                                                                                                                                            type ListSchedulesAPIClient

                                                                                                                                                                            type ListSchedulesAPIClient interface {
                                                                                                                                                                            	ListSchedules(context.Context, *ListSchedulesInput, ...func(*Options)) (*ListSchedulesOutput, error)
                                                                                                                                                                            }

                                                                                                                                                                              ListSchedulesAPIClient is a client that implements the ListSchedules operation.

                                                                                                                                                                              type ListSchedulesInput

                                                                                                                                                                              type ListSchedulesInput struct {
                                                                                                                                                                              
                                                                                                                                                                              	// The name of the job that these schedules apply to.
                                                                                                                                                                              	JobName *string
                                                                                                                                                                              
                                                                                                                                                                              	// The maximum number of results to return in this request.
                                                                                                                                                                              	MaxResults *int32
                                                                                                                                                                              
                                                                                                                                                                              	// A pagination token that can be used in a subsequent request.
                                                                                                                                                                              	NextToken *string
                                                                                                                                                                              }

                                                                                                                                                                              type ListSchedulesOutput

                                                                                                                                                                              type ListSchedulesOutput struct {
                                                                                                                                                                              
                                                                                                                                                                              	// A list of schedules in the current AWS account.
                                                                                                                                                                              	//
                                                                                                                                                                              	// This member is required.
                                                                                                                                                                              	Schedules []types.Schedule
                                                                                                                                                                              
                                                                                                                                                                              	// A token generated by DataBrew that specifies where to continue pagination if a
                                                                                                                                                                              	// previous request was truncated. To get the next set of pages, pass in the
                                                                                                                                                                              	// NextToken value from the response object of the previous page call.
                                                                                                                                                                              	NextToken *string
                                                                                                                                                                              
                                                                                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                                                                                              }

                                                                                                                                                                              type ListSchedulesPaginator

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

                                                                                                                                                                                ListSchedulesPaginator is a paginator for ListSchedules

                                                                                                                                                                                func NewListSchedulesPaginator

                                                                                                                                                                                func NewListSchedulesPaginator(client ListSchedulesAPIClient, params *ListSchedulesInput, optFns ...func(*ListSchedulesPaginatorOptions)) *ListSchedulesPaginator

                                                                                                                                                                                  NewListSchedulesPaginator returns a new ListSchedulesPaginator

                                                                                                                                                                                  func (*ListSchedulesPaginator) HasMorePages

                                                                                                                                                                                  func (p *ListSchedulesPaginator) HasMorePages() bool

                                                                                                                                                                                    HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                                    func (*ListSchedulesPaginator) NextPage

                                                                                                                                                                                    func (p *ListSchedulesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListSchedulesOutput, error)

                                                                                                                                                                                      NextPage retrieves the next ListSchedules page.

                                                                                                                                                                                      type ListSchedulesPaginatorOptions

                                                                                                                                                                                      type ListSchedulesPaginatorOptions struct {
                                                                                                                                                                                      	// The maximum number of results to return in this request.
                                                                                                                                                                                      	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
                                                                                                                                                                                      }

                                                                                                                                                                                        ListSchedulesPaginatorOptions is the paginator options for ListSchedules

                                                                                                                                                                                        type ListTagsForResourceInput

                                                                                                                                                                                        type ListTagsForResourceInput struct {
                                                                                                                                                                                        
                                                                                                                                                                                        	// The Amazon Resource Name (ARN) string that uniquely identifies the DataBrew
                                                                                                                                                                                        	// resource.
                                                                                                                                                                                        	//
                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                        	ResourceArn *string
                                                                                                                                                                                        }

                                                                                                                                                                                        type ListTagsForResourceOutput

                                                                                                                                                                                        type ListTagsForResourceOutput struct {
                                                                                                                                                                                        
                                                                                                                                                                                        	// A list of tags associated with the DataBrew resource.
                                                                                                                                                                                        	Tags map[string]string
                                                                                                                                                                                        
                                                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                                                        }

                                                                                                                                                                                        type Options

                                                                                                                                                                                        type Options struct {
                                                                                                                                                                                        	// Set of options to modify how an operation is invoked. These apply to all
                                                                                                                                                                                        	// operations invoked for this client. Use functional options on operation call to
                                                                                                                                                                                        	// modify this list for per operation behavior.
                                                                                                                                                                                        	APIOptions []func(*middleware.Stack) error
                                                                                                                                                                                        
                                                                                                                                                                                        	// Configures the events that will be sent to the configured logger.
                                                                                                                                                                                        	ClientLogMode aws.ClientLogMode
                                                                                                                                                                                        
                                                                                                                                                                                        	// The credentials object to use when signing requests.
                                                                                                                                                                                        	Credentials aws.CredentialsProvider
                                                                                                                                                                                        
                                                                                                                                                                                        	// The endpoint options to be used when attempting to resolve an endpoint.
                                                                                                                                                                                        	EndpointOptions EndpointResolverOptions
                                                                                                                                                                                        
                                                                                                                                                                                        	// The service endpoint resolver.
                                                                                                                                                                                        	EndpointResolver EndpointResolver
                                                                                                                                                                                        
                                                                                                                                                                                        	// Signature Version 4 (SigV4) Signer
                                                                                                                                                                                        	HTTPSignerV4 HTTPSignerV4
                                                                                                                                                                                        
                                                                                                                                                                                        	// The logger writer interface to write logging messages to.
                                                                                                                                                                                        	Logger logging.Logger
                                                                                                                                                                                        
                                                                                                                                                                                        	// The region to send requests to. (Required)
                                                                                                                                                                                        	Region string
                                                                                                                                                                                        
                                                                                                                                                                                        	// Retryer guides how HTTP requests should be retried in case of recoverable
                                                                                                                                                                                        	// failures. When nil the API client will use a default retryer.
                                                                                                                                                                                        	Retryer aws.Retryer
                                                                                                                                                                                        
                                                                                                                                                                                        	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
                                                                                                                                                                                        	// implementation if nil.
                                                                                                                                                                                        	HTTPClient HTTPClient
                                                                                                                                                                                        }

                                                                                                                                                                                        func (Options) Copy

                                                                                                                                                                                        func (o Options) Copy() Options

                                                                                                                                                                                          Copy creates a clone where the APIOptions list is deep copied.

                                                                                                                                                                                          type PublishRecipeInput

                                                                                                                                                                                          type PublishRecipeInput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the recipe to be published.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// A description of the recipe to be published, for this version of the recipe.
                                                                                                                                                                                          	Description *string
                                                                                                                                                                                          }

                                                                                                                                                                                          type PublishRecipeOutput

                                                                                                                                                                                          type PublishRecipeOutput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the recipe that you published.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                          }

                                                                                                                                                                                          type ResolveEndpoint

                                                                                                                                                                                          type ResolveEndpoint struct {
                                                                                                                                                                                          	Resolver EndpointResolver
                                                                                                                                                                                          	Options  EndpointResolverOptions
                                                                                                                                                                                          }

                                                                                                                                                                                          func (*ResolveEndpoint) HandleSerialize

                                                                                                                                                                                          func (*ResolveEndpoint) ID

                                                                                                                                                                                          func (*ResolveEndpoint) ID() string

                                                                                                                                                                                          type SendProjectSessionActionInput

                                                                                                                                                                                          type SendProjectSessionActionInput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the project to apply the action to.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// A unique identifier for an interactive session that's currently open and ready
                                                                                                                                                                                          	// for work. The action will be performed on this session.
                                                                                                                                                                                          	ClientSessionId *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Returns the result of the recipe step, without applying it. The result isn't
                                                                                                                                                                                          	// added to the view frame stack.
                                                                                                                                                                                          	Preview bool
                                                                                                                                                                                          
                                                                                                                                                                                          	// Represents a single step to be performed in an AWS Glue DataBrew recipe.
                                                                                                                                                                                          	RecipeStep *types.RecipeStep
                                                                                                                                                                                          
                                                                                                                                                                                          	// The index from which to preview a step. This index is used to preview the result
                                                                                                                                                                                          	// of steps that have already been applied, so that the resulting view frame is
                                                                                                                                                                                          	// from earlier in the view frame stack.
                                                                                                                                                                                          	StepIndex *int32
                                                                                                                                                                                          
                                                                                                                                                                                          	// Represents the data being being transformed during an AWS Glue DataBrew project
                                                                                                                                                                                          	// session.
                                                                                                                                                                                          	ViewFrame *types.ViewFrame
                                                                                                                                                                                          }

                                                                                                                                                                                          type SendProjectSessionActionOutput

                                                                                                                                                                                          type SendProjectSessionActionOutput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the project that was affected by the action.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// A unique identifier for the action that was performed.
                                                                                                                                                                                          	ActionId *int32
                                                                                                                                                                                          
                                                                                                                                                                                          	// A message indicating the result of performing the action.
                                                                                                                                                                                          	Result *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                          }

                                                                                                                                                                                          type StartJobRunInput

                                                                                                                                                                                          type StartJobRunInput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the job to be run.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          }

                                                                                                                                                                                          type StartJobRunOutput

                                                                                                                                                                                          type StartJobRunOutput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// A system-generated identifier for this particular job run.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	RunId *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                          }

                                                                                                                                                                                          type StartProjectSessionInput

                                                                                                                                                                                          type StartProjectSessionInput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the project to act upon.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// A value that, if true, enables you to take control of a session, even if a
                                                                                                                                                                                          	// different client is currently accessing the project.
                                                                                                                                                                                          	AssumeControl bool
                                                                                                                                                                                          }

                                                                                                                                                                                          type StartProjectSessionOutput

                                                                                                                                                                                          type StartProjectSessionOutput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the project to be acted upon.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// A system-generated identifier for the session.
                                                                                                                                                                                          	ClientSessionId *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                          }

                                                                                                                                                                                          type StopJobRunInput

                                                                                                                                                                                          type StopJobRunInput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the job to be stopped.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The ID of the job run to be stopped.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	RunId *string
                                                                                                                                                                                          }

                                                                                                                                                                                          type StopJobRunOutput

                                                                                                                                                                                          type StopJobRunOutput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The ID of the job run that you stopped.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	RunId *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                          }

                                                                                                                                                                                          type TagResourceInput

                                                                                                                                                                                          type TagResourceInput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The DataBrew resource to which tags should be added. The value for this
                                                                                                                                                                                          	// parameter is an Amazon Resource Name (ARN). For DataBrew, you can tag a dataset,
                                                                                                                                                                                          	// a job, a project, or a recipe.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	ResourceArn *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// One or more tags to be assigned to the resource.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Tags map[string]string
                                                                                                                                                                                          }

                                                                                                                                                                                          type TagResourceOutput

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

                                                                                                                                                                                          type UntagResourceInput

                                                                                                                                                                                          type UntagResourceInput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// An DataBrew resource from which you want to remove a tag or tags. The value for
                                                                                                                                                                                          	// this parameter is an Amazon Resource Name (ARN).
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	ResourceArn *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The tag keys (names) of one or more tags to be removed.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	TagKeys []string
                                                                                                                                                                                          }

                                                                                                                                                                                          type UntagResourceOutput

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

                                                                                                                                                                                          type UpdateDatasetInput

                                                                                                                                                                                          type UpdateDatasetInput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// Information on how AWS Glue DataBrew can find data, in either the AWS Glue Data
                                                                                                                                                                                          	// Catalog or Amazon S3.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Input *types.Input
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the dataset to be updated.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Options that define how Microsoft Excel input is to be interpreted by DataBrew.
                                                                                                                                                                                          	FormatOptions *types.FormatOptions
                                                                                                                                                                                          }

                                                                                                                                                                                          type UpdateDatasetOutput

                                                                                                                                                                                          type UpdateDatasetOutput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the dataset that you updated.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                          }

                                                                                                                                                                                          type UpdateProfileJobInput

                                                                                                                                                                                          type UpdateProfileJobInput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the job to be updated.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// An Amazon S3 location (bucket name an object key) where DataBrew can read input
                                                                                                                                                                                          	// data, or write output from a job.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	OutputLocation *types.S3Location
                                                                                                                                                                                          
                                                                                                                                                                                          	// The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM)
                                                                                                                                                                                          	// role to be assumed for this request.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	RoleArn *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The Amazon Resource Name (ARN) of an encryption key that is used to protect the
                                                                                                                                                                                          	// job.
                                                                                                                                                                                          	EncryptionKeyArn *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The encryption mode for the job, which can be one of the following:
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// * SSE-KMS -
                                                                                                                                                                                          	// Server-side encryption with AWS KMS-managed keys.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// * SSE-S3 - Server-side
                                                                                                                                                                                          	// encryption with keys managed by Amazon S3.
                                                                                                                                                                                          	EncryptionMode types.EncryptionMode
                                                                                                                                                                                          
                                                                                                                                                                                          	// A value that enables or disables Amazon CloudWatch logging for the current AWS
                                                                                                                                                                                          	// account. If logging is enabled, CloudWatch writes one log stream for each job
                                                                                                                                                                                          	// run.
                                                                                                                                                                                          	LogSubscription types.LogSubscription
                                                                                                                                                                                          
                                                                                                                                                                                          	// The maximum number of nodes that DataBrew can use when the job processes data.
                                                                                                                                                                                          	MaxCapacity int32
                                                                                                                                                                                          
                                                                                                                                                                                          	// The maximum number of times to retry the job after a job run fails.
                                                                                                                                                                                          	MaxRetries int32
                                                                                                                                                                                          
                                                                                                                                                                                          	// The job's timeout in minutes. A job that attempts to run longer than this
                                                                                                                                                                                          	// timeout period ends with a status of TIMEOUT.
                                                                                                                                                                                          	Timeout int32
                                                                                                                                                                                          }

                                                                                                                                                                                          type UpdateProfileJobOutput

                                                                                                                                                                                          type UpdateProfileJobOutput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the job that was updated.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                          }

                                                                                                                                                                                          type UpdateProjectInput

                                                                                                                                                                                          type UpdateProjectInput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the project to be updated.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The Amazon Resource Name (ARN) of the IAM role to be assumed for this request.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	RoleArn *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Represents the sample size and sampling type for AWS Glue DataBrew to use for
                                                                                                                                                                                          	// interactive data analysis.
                                                                                                                                                                                          	Sample *types.Sample
                                                                                                                                                                                          }

                                                                                                                                                                                          type UpdateProjectOutput

                                                                                                                                                                                          type UpdateProjectOutput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the project that you updated.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The date and time that the project was last modified.
                                                                                                                                                                                          	LastModifiedDate *time.Time
                                                                                                                                                                                          
                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                          }

                                                                                                                                                                                          type UpdateRecipeInput

                                                                                                                                                                                          type UpdateRecipeInput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the recipe to be updated.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// A description of the recipe.
                                                                                                                                                                                          	Description *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// One or more steps to be performed by the recipe. Each step consists of an
                                                                                                                                                                                          	// action, and the conditions under which the action should succeed.
                                                                                                                                                                                          	Steps []types.RecipeStep
                                                                                                                                                                                          }

                                                                                                                                                                                          type UpdateRecipeJobInput

                                                                                                                                                                                          type UpdateRecipeJobInput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the job to update.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// One or more artifacts that represent the output from running the job.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Outputs []types.Output
                                                                                                                                                                                          
                                                                                                                                                                                          	// The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM)
                                                                                                                                                                                          	// role to be assumed for this request.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	RoleArn *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The Amazon Resource Name (ARN) of an encryption key that is used to protect the
                                                                                                                                                                                          	// job.
                                                                                                                                                                                          	EncryptionKeyArn *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The encryption mode for the job, which can be one of the following:
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// * SSE-KMS -
                                                                                                                                                                                          	// Server-side encryption with AWS KMS-managed keys.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// * SSE-S3 - Server-side
                                                                                                                                                                                          	// encryption with keys managed by Amazon S3.
                                                                                                                                                                                          	EncryptionMode types.EncryptionMode
                                                                                                                                                                                          
                                                                                                                                                                                          	// A value that enables or disables Amazon CloudWatch logging for the current AWS
                                                                                                                                                                                          	// account. If logging is enabled, CloudWatch writes one log stream for each job
                                                                                                                                                                                          	// run.
                                                                                                                                                                                          	LogSubscription types.LogSubscription
                                                                                                                                                                                          
                                                                                                                                                                                          	// The maximum number of nodes that DataBrew can consume when the job processes
                                                                                                                                                                                          	// data.
                                                                                                                                                                                          	MaxCapacity int32
                                                                                                                                                                                          
                                                                                                                                                                                          	// The maximum number of times to retry the job after a job run fails.
                                                                                                                                                                                          	MaxRetries int32
                                                                                                                                                                                          
                                                                                                                                                                                          	// The job's timeout in minutes. A job that attempts to run longer than this
                                                                                                                                                                                          	// timeout period ends with a status of TIMEOUT.
                                                                                                                                                                                          	Timeout int32
                                                                                                                                                                                          }

                                                                                                                                                                                          type UpdateRecipeJobOutput

                                                                                                                                                                                          type UpdateRecipeJobOutput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the job that you updated.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                          }

                                                                                                                                                                                          type UpdateRecipeOutput

                                                                                                                                                                                          type UpdateRecipeOutput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the recipe that was updated.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                          }

                                                                                                                                                                                          type UpdateScheduleInput

                                                                                                                                                                                          type UpdateScheduleInput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The date or dates and time or times, in cron format, when the jobs are to be
                                                                                                                                                                                          	// run.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	CronExpression *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the schedule to update.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name or names of one or more jobs to be run for this schedule.
                                                                                                                                                                                          	JobNames []string
                                                                                                                                                                                          }

                                                                                                                                                                                          type UpdateScheduleOutput

                                                                                                                                                                                          type UpdateScheduleOutput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// The name of the schedule that was updated.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	Name *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                          }

                                                                                                                                                                                          Directories

                                                                                                                                                                                          Path Synopsis
                                                                                                                                                                                          internal