Documentation

Overview

    Package personalize provides the API client, operations, and parameter types for Amazon Personalize.

    Amazon Personalize is a machine learning service that makes it easy to add individualized recommendations to customers.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2018-05-22"
    View Source
    const ServiceID = "Personalize"

    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 Client

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

            Client provides the API client to make operations call for Amazon Personalize.

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

                func (c *Client) CreateBatchInferenceJob(ctx context.Context, params *CreateBatchInferenceJobInput, optFns ...func(*Options)) (*CreateBatchInferenceJobOutput, error)

                  Creates a batch inference job. The operation can handle up to 50 million records and the input file must be in JSON format. For more information, see recommendations-batch.

                  func (*Client) CreateCampaign

                  func (c *Client) CreateCampaign(ctx context.Context, params *CreateCampaignInput, optFns ...func(*Options)) (*CreateCampaignOutput, error)

                    Creates a campaign by deploying a solution version. When a client calls the GetRecommendations (https://docs.aws.amazon.com/personalize/latest/dg/API_RS_GetRecommendations.html) and GetPersonalizedRanking (https://docs.aws.amazon.com/personalize/latest/dg/API_RS_GetPersonalizedRanking.html) APIs, a campaign is specified in the request. Minimum Provisioned TPS and Auto-Scaling A transaction is a single GetRecommendations or GetPersonalizedRanking call. Transactions per second (TPS) is the throughput and unit of billing for Amazon Personalize. The minimum provisioned TPS (minProvisionedTPS) specifies the baseline throughput provisioned by Amazon Personalize, and thus, the minimum billing charge. If your TPS increases beyond minProvisionedTPS, Amazon Personalize auto-scales the provisioned capacity up and down, but never below minProvisionedTPS. There's a short time delay while the capacity is increased that might cause loss of transactions. The actual TPS used is calculated as the average requests/second within a 5-minute window. You pay for maximum of either the minimum provisioned TPS or the actual TPS. We recommend starting with a low minProvisionedTPS, track your usage using Amazon CloudWatch metrics, and then increase the minProvisionedTPS as necessary. Status A campaign can be in one of the following states:

                    * CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED

                    * DELETE PENDING > DELETE IN_PROGRESS

                    To get the campaign status, call DescribeCampaign. Wait until the status of the campaign is ACTIVE before asking the campaign for recommendations. Related APIs

                    * ListCampaigns

                    * DescribeCampaign

                    * UpdateCampaign

                    * DeleteCampaign

                    func (*Client) CreateDataset

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

                      Creates an empty dataset and adds it to the specified dataset group. Use CreateDatasetImportJob to import your training data to a dataset. There are three types of datasets:

                      * Interactions

                      * Items

                      * Users

                      Each dataset type has an associated schema with required field types. Only the Interactions dataset is required in order to train a model (also referred to as creating a solution). A dataset can be in one of the following states:

                      * CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED

                      * DELETE PENDING > DELETE IN_PROGRESS

                      To get the status of the dataset, call DescribeDataset. Related APIs

                      * CreateDatasetGroup

                      * ListDatasets

                      * DescribeDataset

                      * DeleteDataset

                      func (*Client) CreateDatasetGroup

                      func (c *Client) CreateDatasetGroup(ctx context.Context, params *CreateDatasetGroupInput, optFns ...func(*Options)) (*CreateDatasetGroupOutput, error)

                        Creates an empty dataset group. A dataset group contains related datasets that supply data for training a model. A dataset group can contain at most three datasets, one for each type of dataset:

                        * Interactions

                        * Items

                        * Users

                        To train a model (create a solution), a dataset group that contains an Interactions dataset is required. Call CreateDataset to add a dataset to the group. A dataset group can be in one of the following states:

                        * CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED

                        * DELETE PENDING

                        To get the status of the dataset group, call DescribeDatasetGroup. If the status shows as CREATE FAILED, the response includes a failureReason key, which describes why the creation failed. You must wait until the status of the dataset group is ACTIVE before adding a dataset to the group. You can specify an AWS Key Management Service (KMS) key to encrypt the datasets in the group. If you specify a KMS key, you must also include an AWS Identity and Access Management (IAM) role that has permission to access the key. APIs that require a dataset group ARN in the request

                        * CreateDataset

                        * CreateEventTracker

                        * CreateSolution

                        Related APIs

                        * ListDatasetGroups

                        * DescribeDatasetGroup

                        * DeleteDatasetGroup

                        func (*Client) CreateDatasetImportJob

                        func (c *Client) CreateDatasetImportJob(ctx context.Context, params *CreateDatasetImportJobInput, optFns ...func(*Options)) (*CreateDatasetImportJobOutput, error)

                          Creates a job that imports training data from your data source (an Amazon S3 bucket) to an Amazon Personalize dataset. To allow Amazon Personalize to import the training data, you must specify an AWS Identity and Access Management (IAM) role that has permission to read from the data source, as Amazon Personalize makes a copy of your data and processes it in an internal AWS system. The dataset import job replaces any existing data in the dataset that you imported in bulk. Status A dataset import job can be in one of the following states:

                          * CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED

                          To get the status of the import job, call DescribeDatasetImportJob, providing the Amazon Resource Name (ARN) of the dataset import job. The dataset import is complete when the status shows as ACTIVE. If the status shows as CREATE FAILED, the response includes a failureReason key, which describes why the job failed. Importing takes time. You must wait until the status shows as ACTIVE before training a model using the dataset. Related APIs

                          * ListDatasetImportJobs

                          * DescribeDatasetImportJob

                          func (*Client) CreateEventTracker

                          func (c *Client) CreateEventTracker(ctx context.Context, params *CreateEventTrackerInput, optFns ...func(*Options)) (*CreateEventTrackerOutput, error)

                            Creates an event tracker that you use when adding event data to a specified dataset group using the PutEvents (https://docs.aws.amazon.com/personalize/latest/dg/API_UBS_PutEvents.html) API. Only one event tracker can be associated with a dataset group. You will get an error if you call CreateEventTracker using the same dataset group as an existing event tracker. When you create an event tracker, the response includes a tracking ID, which you pass as a parameter when you use the PutEvents (https://docs.aws.amazon.com/personalize/latest/dg/API_UBS_PutEvents.html) operation. Amazon Personalize then appends the event data to the Interactions dataset of the dataset group you specify in your event tracker. The event tracker can be in one of the following states:

                            * CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED

                            * DELETE PENDING > DELETE IN_PROGRESS

                            To get the status of the event tracker, call DescribeEventTracker. The event tracker must be in the ACTIVE state before using the tracking ID. Related APIs

                            * ListEventTrackers

                            * DescribeEventTracker

                            * DeleteEventTracker

                            func (*Client) CreateFilter

                            func (c *Client) CreateFilter(ctx context.Context, params *CreateFilterInput, optFns ...func(*Options)) (*CreateFilterOutput, error)

                              Creates a recommendation filter. For more information, see filter.

                              func (*Client) CreateSchema

                              func (c *Client) CreateSchema(ctx context.Context, params *CreateSchemaInput, optFns ...func(*Options)) (*CreateSchemaOutput, error)

                                Creates an Amazon Personalize schema from the specified schema string. The schema you create must be in Avro JSON format. Amazon Personalize recognizes three schema variants. Each schema is associated with a dataset type and has a set of required field and keywords. You specify a schema when you call CreateDataset. Related APIs

                                * ListSchemas

                                * DescribeSchema

                                * DeleteSchema

                                func (*Client) CreateSolution

                                func (c *Client) CreateSolution(ctx context.Context, params *CreateSolutionInput, optFns ...func(*Options)) (*CreateSolutionOutput, error)

                                  Creates the configuration for training a model. A trained model is known as a solution. After the configuration is created, you train the model (create a solution) by calling the CreateSolutionVersion operation. Every time you call CreateSolutionVersion, a new version of the solution is created. After creating a solution version, you check its accuracy by calling GetSolutionMetrics. When you are satisfied with the version, you deploy it using CreateCampaign. The campaign provides recommendations to a client through the GetRecommendations (https://docs.aws.amazon.com/personalize/latest/dg/API_RS_GetRecommendations.html) API. To train a model, Amazon Personalize requires training data and a recipe. The training data comes from the dataset group that you provide in the request. A recipe specifies the training algorithm and a feature transformation. You can specify one of the predefined recipes provided by Amazon Personalize. Alternatively, you can specify performAutoML and Amazon Personalize will analyze your data and select the optimum USER_PERSONALIZATION recipe for you. Amazon Personalize doesn't support configuring the hpoObjective for solution hyperparameter optimization at this time. Status A solution can be in one of the following states:

                                  * CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED

                                  * DELETE PENDING > DELETE IN_PROGRESS

                                  To get the status of the solution, call DescribeSolution. Wait until the status shows as ACTIVE before calling CreateSolutionVersion. Related APIs

                                  * ListSolutions

                                  * CreateSolutionVersion

                                  * DescribeSolution

                                  * DeleteSolution

                                  * ListSolutionVersions

                                  * DescribeSolutionVersion

                                  func (*Client) CreateSolutionVersion

                                  func (c *Client) CreateSolutionVersion(ctx context.Context, params *CreateSolutionVersionInput, optFns ...func(*Options)) (*CreateSolutionVersionOutput, error)

                                    Trains or retrains an active solution. A solution is created using the CreateSolution operation and must be in the ACTIVE state before calling CreateSolutionVersion. A new version of the solution is created every time you call this operation. Status A solution version can be in one of the following states:

                                    * CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED

                                    To get the status of the version, call DescribeSolutionVersion. Wait until the status shows as ACTIVE before calling CreateCampaign. If the status shows as CREATE FAILED, the response includes a failureReason key, which describes why the job failed. Related APIs

                                    * ListSolutionVersions

                                    * DescribeSolutionVersion

                                    * ListSolutions

                                    * CreateSolution

                                    * DescribeSolution

                                    * DeleteSolution

                                    func (*Client) DeleteCampaign

                                    func (c *Client) DeleteCampaign(ctx context.Context, params *DeleteCampaignInput, optFns ...func(*Options)) (*DeleteCampaignOutput, error)

                                      Removes a campaign by deleting the solution deployment. The solution that the campaign is based on is not deleted and can be redeployed when needed. A deleted campaign can no longer be specified in a GetRecommendations (https://docs.aws.amazon.com/personalize/latest/dg/API_RS_GetRecommendations.html) request. For more information on campaigns, see CreateCampaign.

                                      func (*Client) DeleteDataset

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

                                        Deletes a dataset. You can't delete a dataset if an associated DatasetImportJob or SolutionVersion is in the CREATE PENDING or IN PROGRESS state. For more information on datasets, see CreateDataset.

                                        func (*Client) DeleteDatasetGroup

                                        func (c *Client) DeleteDatasetGroup(ctx context.Context, params *DeleteDatasetGroupInput, optFns ...func(*Options)) (*DeleteDatasetGroupOutput, error)

                                          Deletes a dataset group. Before you delete a dataset group, you must delete the following:

                                          * All associated event trackers.

                                          * All associated solutions.

                                          * All datasets in the dataset group.

                                          func (*Client) DeleteEventTracker

                                          func (c *Client) DeleteEventTracker(ctx context.Context, params *DeleteEventTrackerInput, optFns ...func(*Options)) (*DeleteEventTrackerOutput, error)

                                            Deletes the event tracker. Does not delete the event-interactions dataset from the associated dataset group. For more information on event trackers, see CreateEventTracker.

                                            func (*Client) DeleteFilter

                                            func (c *Client) DeleteFilter(ctx context.Context, params *DeleteFilterInput, optFns ...func(*Options)) (*DeleteFilterOutput, error)

                                              Deletes a filter.

                                              func (*Client) DeleteSchema

                                              func (c *Client) DeleteSchema(ctx context.Context, params *DeleteSchemaInput, optFns ...func(*Options)) (*DeleteSchemaOutput, error)

                                                Deletes a schema. Before deleting a schema, you must delete all datasets referencing the schema. For more information on schemas, see CreateSchema.

                                                func (*Client) DeleteSolution

                                                func (c *Client) DeleteSolution(ctx context.Context, params *DeleteSolutionInput, optFns ...func(*Options)) (*DeleteSolutionOutput, error)

                                                  Deletes all versions of a solution and the Solution object itself. Before deleting a solution, you must delete all campaigns based on the solution. To determine what campaigns are using the solution, call ListCampaigns and supply the Amazon Resource Name (ARN) of the solution. You can't delete a solution if an associated SolutionVersion is in the CREATE PENDING or IN PROGRESS state. For more information on solutions, see CreateSolution.

                                                  func (*Client) DescribeAlgorithm

                                                  func (c *Client) DescribeAlgorithm(ctx context.Context, params *DescribeAlgorithmInput, optFns ...func(*Options)) (*DescribeAlgorithmOutput, error)

                                                    Describes the given algorithm.

                                                    func (*Client) DescribeBatchInferenceJob

                                                    func (c *Client) DescribeBatchInferenceJob(ctx context.Context, params *DescribeBatchInferenceJobInput, optFns ...func(*Options)) (*DescribeBatchInferenceJobOutput, error)

                                                      Gets the properties of a batch inference job including name, Amazon Resource Name (ARN), status, input and output configurations, and the ARN of the solution version used to generate the recommendations.

                                                      func (*Client) DescribeCampaign

                                                      func (c *Client) DescribeCampaign(ctx context.Context, params *DescribeCampaignInput, optFns ...func(*Options)) (*DescribeCampaignOutput, error)

                                                        Describes the given campaign, including its status. A campaign can be in one of the following states:

                                                        * CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED

                                                        * DELETE PENDING > DELETE IN_PROGRESS

                                                        When the status is CREATE FAILED, the response includes the failureReason key, which describes why. For more information on campaigns, see CreateCampaign.

                                                        func (*Client) DescribeDataset

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

                                                          Describes the given dataset. For more information on datasets, see CreateDataset.

                                                          func (*Client) DescribeDatasetGroup

                                                          func (c *Client) DescribeDatasetGroup(ctx context.Context, params *DescribeDatasetGroupInput, optFns ...func(*Options)) (*DescribeDatasetGroupOutput, error)

                                                            Describes the given dataset group. For more information on dataset groups, see CreateDatasetGroup.

                                                            func (*Client) DescribeDatasetImportJob

                                                            func (c *Client) DescribeDatasetImportJob(ctx context.Context, params *DescribeDatasetImportJobInput, optFns ...func(*Options)) (*DescribeDatasetImportJobOutput, error)

                                                              Describes the dataset import job created by CreateDatasetImportJob, including the import job status.

                                                              func (*Client) DescribeEventTracker

                                                              func (c *Client) DescribeEventTracker(ctx context.Context, params *DescribeEventTrackerInput, optFns ...func(*Options)) (*DescribeEventTrackerOutput, error)

                                                                Describes an event tracker. The response includes the trackingId and status of the event tracker. For more information on event trackers, see CreateEventTracker.

                                                                func (*Client) DescribeFeatureTransformation

                                                                func (c *Client) DescribeFeatureTransformation(ctx context.Context, params *DescribeFeatureTransformationInput, optFns ...func(*Options)) (*DescribeFeatureTransformationOutput, error)

                                                                  Describes the given feature transformation.

                                                                  func (*Client) DescribeFilter

                                                                  func (c *Client) DescribeFilter(ctx context.Context, params *DescribeFilterInput, optFns ...func(*Options)) (*DescribeFilterOutput, error)

                                                                    Describes a filter's properties.

                                                                    func (*Client) DescribeRecipe

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

                                                                      Describes a recipe. A recipe contains three items:

                                                                      * An algorithm that trains a model.

                                                                      * Hyperparameters that govern the training.

                                                                      * Feature transformation information for modifying the input data before training.

                                                                      Amazon Personalize provides a set of predefined recipes. You specify a recipe when you create a solution with the CreateSolution API. CreateSolution trains a model by using the algorithm in the specified recipe and a training dataset. The solution, when deployed as a campaign, can provide recommendations using the GetRecommendations (https://docs.aws.amazon.com/personalize/latest/dg/API_RS_GetRecommendations.html) API.

                                                                      func (*Client) DescribeSchema

                                                                      func (c *Client) DescribeSchema(ctx context.Context, params *DescribeSchemaInput, optFns ...func(*Options)) (*DescribeSchemaOutput, error)

                                                                        Describes a schema. For more information on schemas, see CreateSchema.

                                                                        func (*Client) DescribeSolution

                                                                        func (c *Client) DescribeSolution(ctx context.Context, params *DescribeSolutionInput, optFns ...func(*Options)) (*DescribeSolutionOutput, error)

                                                                          Describes a solution. For more information on solutions, see CreateSolution.

                                                                          func (*Client) DescribeSolutionVersion

                                                                          func (c *Client) DescribeSolutionVersion(ctx context.Context, params *DescribeSolutionVersionInput, optFns ...func(*Options)) (*DescribeSolutionVersionOutput, error)

                                                                            Describes a specific version of a solution. For more information on solutions, see CreateSolution.

                                                                            func (*Client) GetSolutionMetrics

                                                                            func (c *Client) GetSolutionMetrics(ctx context.Context, params *GetSolutionMetricsInput, optFns ...func(*Options)) (*GetSolutionMetricsOutput, error)

                                                                              Gets the metrics for the specified solution version.

                                                                              func (*Client) ListBatchInferenceJobs

                                                                              func (c *Client) ListBatchInferenceJobs(ctx context.Context, params *ListBatchInferenceJobsInput, optFns ...func(*Options)) (*ListBatchInferenceJobsOutput, error)

                                                                                Gets a list of the batch inference jobs that have been performed off of a solution version.

                                                                                func (*Client) ListCampaigns

                                                                                func (c *Client) ListCampaigns(ctx context.Context, params *ListCampaignsInput, optFns ...func(*Options)) (*ListCampaignsOutput, error)

                                                                                  Returns a list of campaigns that use the given solution. When a solution is not specified, all the campaigns associated with the account are listed. The response provides the properties for each campaign, including the Amazon Resource Name (ARN). For more information on campaigns, see CreateCampaign.

                                                                                  func (*Client) ListDatasetGroups

                                                                                  func (c *Client) ListDatasetGroups(ctx context.Context, params *ListDatasetGroupsInput, optFns ...func(*Options)) (*ListDatasetGroupsOutput, error)

                                                                                    Returns a list of dataset groups. The response provides the properties for each dataset group, including the Amazon Resource Name (ARN). For more information on dataset groups, see CreateDatasetGroup.

                                                                                    func (*Client) ListDatasetImportJobs

                                                                                    func (c *Client) ListDatasetImportJobs(ctx context.Context, params *ListDatasetImportJobsInput, optFns ...func(*Options)) (*ListDatasetImportJobsOutput, error)

                                                                                      Returns a list of dataset import jobs that use the given dataset. When a dataset is not specified, all the dataset import jobs associated with the account are listed. The response provides the properties for each dataset import job, including the Amazon Resource Name (ARN). For more information on dataset import jobs, see CreateDatasetImportJob. For more information on datasets, see CreateDataset.

                                                                                      func (*Client) ListDatasets

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

                                                                                        Returns the list of datasets contained in the given dataset group. The response provides the properties for each dataset, including the Amazon Resource Name (ARN). For more information on datasets, see CreateDataset.

                                                                                        func (*Client) ListEventTrackers

                                                                                        func (c *Client) ListEventTrackers(ctx context.Context, params *ListEventTrackersInput, optFns ...func(*Options)) (*ListEventTrackersOutput, error)

                                                                                          Returns the list of event trackers associated with the account. The response provides the properties for each event tracker, including the Amazon Resource Name (ARN) and tracking ID. For more information on event trackers, see CreateEventTracker.

                                                                                          func (*Client) ListFilters

                                                                                          func (c *Client) ListFilters(ctx context.Context, params *ListFiltersInput, optFns ...func(*Options)) (*ListFiltersOutput, error)

                                                                                            Lists all filters that belong to a given dataset group.

                                                                                            func (*Client) ListRecipes

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

                                                                                              Returns a list of available recipes. The response provides the properties for each recipe, including the recipe's Amazon Resource Name (ARN).

                                                                                              func (*Client) ListSchemas

                                                                                              func (c *Client) ListSchemas(ctx context.Context, params *ListSchemasInput, optFns ...func(*Options)) (*ListSchemasOutput, error)

                                                                                                Returns the list of schemas associated with the account. The response provides the properties for each schema, including the Amazon Resource Name (ARN). For more information on schemas, see CreateSchema.

                                                                                                func (*Client) ListSolutionVersions

                                                                                                func (c *Client) ListSolutionVersions(ctx context.Context, params *ListSolutionVersionsInput, optFns ...func(*Options)) (*ListSolutionVersionsOutput, error)

                                                                                                  Returns a list of solution versions for the given solution. When a solution is not specified, all the solution versions associated with the account are listed. The response provides the properties for each solution version, including the Amazon Resource Name (ARN). For more information on solutions, see CreateSolution.

                                                                                                  func (*Client) ListSolutions

                                                                                                  func (c *Client) ListSolutions(ctx context.Context, params *ListSolutionsInput, optFns ...func(*Options)) (*ListSolutionsOutput, error)

                                                                                                    Returns a list of solutions that use the given dataset group. When a dataset group is not specified, all the solutions associated with the account are listed. The response provides the properties for each solution, including the Amazon Resource Name (ARN). For more information on solutions, see CreateSolution.

                                                                                                    func (*Client) UpdateCampaign

                                                                                                    func (c *Client) UpdateCampaign(ctx context.Context, params *UpdateCampaignInput, optFns ...func(*Options)) (*UpdateCampaignOutput, error)

                                                                                                      Updates a campaign by either deploying a new solution or changing the value of the campaign's minProvisionedTPS parameter. To update a campaign, the campaign status must be ACTIVE or CREATE FAILED. Check the campaign status using the DescribeCampaign API. You must wait until the status of the updated campaign is ACTIVE before asking the campaign for recommendations. For more information on campaigns, see CreateCampaign.

                                                                                                      type CreateBatchInferenceJobInput

                                                                                                      type CreateBatchInferenceJobInput struct {
                                                                                                      
                                                                                                      	// The Amazon S3 path that leads to the input file to base your recommendations on.
                                                                                                      	// The input material must be in JSON format.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	JobInput *types.BatchInferenceJobInput
                                                                                                      
                                                                                                      	// The name of the batch inference job to create.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	JobName *string
                                                                                                      
                                                                                                      	// The path to the Amazon S3 bucket where the job's output will be stored.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	JobOutput *types.BatchInferenceJobOutput
                                                                                                      
                                                                                                      	// The ARN of the Amazon Identity and Access Management role that has permissions
                                                                                                      	// to read and write to your input and out Amazon S3 buckets respectively.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	RoleArn *string
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the solution version that will be used to
                                                                                                      	// generate the batch inference recommendations.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	SolutionVersionArn *string
                                                                                                      
                                                                                                      	// The configuration details of a batch inference job.
                                                                                                      	BatchInferenceJobConfig *types.BatchInferenceJobConfig
                                                                                                      
                                                                                                      	// The ARN of the filter to apply to the batch inference job. For more information
                                                                                                      	// on using filters, see Using Filters with Amazon Personalize.
                                                                                                      	FilterArn *string
                                                                                                      
                                                                                                      	// The number of recommendations to retreive.
                                                                                                      	NumResults *int32
                                                                                                      }

                                                                                                      type CreateBatchInferenceJobOutput

                                                                                                      type CreateBatchInferenceJobOutput struct {
                                                                                                      
                                                                                                      	// The ARN of the batch inference job.
                                                                                                      	BatchInferenceJobArn *string
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type CreateCampaignInput

                                                                                                      type CreateCampaignInput struct {
                                                                                                      
                                                                                                      	// Specifies the requested minimum provisioned transactions (recommendations) per
                                                                                                      	// second that Amazon Personalize will support.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	MinProvisionedTPS *int32
                                                                                                      
                                                                                                      	// A name for the new campaign. The campaign name must be unique within your
                                                                                                      	// account.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	Name *string
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the solution version to deploy.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	SolutionVersionArn *string
                                                                                                      
                                                                                                      	// The configuration details of a campaign.
                                                                                                      	CampaignConfig *types.CampaignConfig
                                                                                                      }

                                                                                                      type CreateCampaignOutput

                                                                                                      type CreateCampaignOutput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the campaign.
                                                                                                      	CampaignArn *string
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type CreateDatasetGroupInput

                                                                                                      type CreateDatasetGroupInput struct {
                                                                                                      
                                                                                                      	// The name for the new dataset group.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	Name *string
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of a KMS key used to encrypt the datasets.
                                                                                                      	KmsKeyArn *string
                                                                                                      
                                                                                                      	// The ARN of the IAM role that has permissions to access the KMS key. Supplying an
                                                                                                      	// IAM role is only valid when also specifying a KMS key.
                                                                                                      	RoleArn *string
                                                                                                      }

                                                                                                      type CreateDatasetGroupOutput

                                                                                                      type CreateDatasetGroupOutput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the new dataset group.
                                                                                                      	DatasetGroupArn *string
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type CreateDatasetImportJobInput

                                                                                                      type CreateDatasetImportJobInput struct {
                                                                                                      
                                                                                                      	// The Amazon S3 bucket that contains the training data to import.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	DataSource *types.DataSource
                                                                                                      
                                                                                                      	// The ARN of the dataset that receives the imported data.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	DatasetArn *string
                                                                                                      
                                                                                                      	// The name for the dataset import job.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	JobName *string
                                                                                                      
                                                                                                      	// The ARN of the IAM role that has permissions to read from the Amazon S3 data
                                                                                                      	// source.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	RoleArn *string
                                                                                                      }

                                                                                                      type CreateDatasetImportJobOutput

                                                                                                      type CreateDatasetImportJobOutput struct {
                                                                                                      
                                                                                                      	// The ARN of the dataset import job.
                                                                                                      	DatasetImportJobArn *string
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type CreateDatasetInput

                                                                                                      type CreateDatasetInput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the dataset group to add the dataset to.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	DatasetGroupArn *string
                                                                                                      
                                                                                                      	// The type of dataset. One of the following (case insensitive) values:
                                                                                                      	//
                                                                                                      	// *
                                                                                                      	// Interactions
                                                                                                      	//
                                                                                                      	// * Items
                                                                                                      	//
                                                                                                      	// * Users
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	DatasetType *string
                                                                                                      
                                                                                                      	// The name for the dataset.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	Name *string
                                                                                                      
                                                                                                      	// The ARN of the schema to associate with the dataset. The schema defines the
                                                                                                      	// dataset fields.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	SchemaArn *string
                                                                                                      }

                                                                                                      type CreateDatasetOutput

                                                                                                      type CreateDatasetOutput struct {
                                                                                                      
                                                                                                      	// The ARN of the dataset.
                                                                                                      	DatasetArn *string
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type CreateEventTrackerInput

                                                                                                      type CreateEventTrackerInput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the dataset group that receives the event
                                                                                                      	// data.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	DatasetGroupArn *string
                                                                                                      
                                                                                                      	// The name for the event tracker.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	Name *string
                                                                                                      }

                                                                                                      type CreateEventTrackerOutput

                                                                                                      type CreateEventTrackerOutput struct {
                                                                                                      
                                                                                                      	// The ARN of the event tracker.
                                                                                                      	EventTrackerArn *string
                                                                                                      
                                                                                                      	// The ID of the event tracker. Include this ID in requests to the PutEvents
                                                                                                      	// (https://docs.aws.amazon.com/personalize/latest/dg/API_UBS_PutEvents.html) API.
                                                                                                      	TrackingId *string
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type CreateFilterInput

                                                                                                      type CreateFilterInput struct {
                                                                                                      
                                                                                                      	// The ARN of the dataset group that the filter will belong to.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	DatasetGroupArn *string
                                                                                                      
                                                                                                      	// The filter expression defines which items are included or excluded from
                                                                                                      	// recommendations. Filter expression must follow specific format rules. For
                                                                                                      	// information about filter expression structure and syntax, see
                                                                                                      	// filter-expressions.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	FilterExpression *string
                                                                                                      
                                                                                                      	// The name of the filter to create.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	Name *string
                                                                                                      }

                                                                                                      type CreateFilterOutput

                                                                                                      type CreateFilterOutput struct {
                                                                                                      
                                                                                                      	// The ARN of the new filter.
                                                                                                      	FilterArn *string
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type CreateSchemaInput

                                                                                                      type CreateSchemaInput struct {
                                                                                                      
                                                                                                      	// The name for the schema.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	Name *string
                                                                                                      
                                                                                                      	// A schema in Avro JSON format.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	Schema *string
                                                                                                      }

                                                                                                      type CreateSchemaOutput

                                                                                                      type CreateSchemaOutput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the created schema.
                                                                                                      	SchemaArn *string
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type CreateSolutionInput

                                                                                                      type CreateSolutionInput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the dataset group that provides the training
                                                                                                      	// data.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	DatasetGroupArn *string
                                                                                                      
                                                                                                      	// The name for the solution.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	Name *string
                                                                                                      
                                                                                                      	// When your have multiple event types (using an EVENT_TYPE schema field), this
                                                                                                      	// parameter specifies which event type (for example, 'click' or 'like') is used
                                                                                                      	// for training the model. If you do not provide an eventType, Amazon Personalize
                                                                                                      	// will use all interactions for training with equal weight regardless of type.
                                                                                                      	EventType *string
                                                                                                      
                                                                                                      	// Whether to perform automated machine learning (AutoML). The default is false.
                                                                                                      	// For this case, you must specify recipeArn. When set to true, Amazon Personalize
                                                                                                      	// analyzes your training data and selects the optimal USER_PERSONALIZATION recipe
                                                                                                      	// and hyperparameters. In this case, you must omit recipeArn. Amazon Personalize
                                                                                                      	// determines the optimal recipe by running tests with different values for the
                                                                                                      	// hyperparameters. AutoML lengthens the training process as compared to selecting
                                                                                                      	// a specific recipe.
                                                                                                      	PerformAutoML bool
                                                                                                      
                                                                                                      	// Whether to perform hyperparameter optimization (HPO) on the specified or
                                                                                                      	// selected recipe. The default is false. When performing AutoML, this parameter is
                                                                                                      	// always true and you should not set it to false.
                                                                                                      	PerformHPO *bool
                                                                                                      
                                                                                                      	// The ARN of the recipe to use for model training. Only specified when
                                                                                                      	// performAutoML is false.
                                                                                                      	RecipeArn *string
                                                                                                      
                                                                                                      	// The configuration to use with the solution. When performAutoML is set to true,
                                                                                                      	// Amazon Personalize only evaluates the autoMLConfig section of the solution
                                                                                                      	// configuration. Amazon Personalize doesn't support configuring the hpoObjective
                                                                                                      	// at this time.
                                                                                                      	SolutionConfig *types.SolutionConfig
                                                                                                      }

                                                                                                      type CreateSolutionOutput

                                                                                                      type CreateSolutionOutput struct {
                                                                                                      
                                                                                                      	// The ARN of the solution.
                                                                                                      	SolutionArn *string
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type CreateSolutionVersionInput

                                                                                                      type CreateSolutionVersionInput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the solution containing the training
                                                                                                      	// configuration information.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	SolutionArn *string
                                                                                                      
                                                                                                      	// The scope of training to be performed when creating the solution version. The
                                                                                                      	// FULL option trains the solution version based on the entirety of the input
                                                                                                      	// solution's training data, while the UPDATE option processes only the data that
                                                                                                      	// has changed in comparison to the input solution. Choose UPDATE when you want to
                                                                                                      	// incrementally update your solution version instead of creating an entirely new
                                                                                                      	// one. The UPDATE option can only be used when you already have an active solution
                                                                                                      	// version created from the input solution using the FULL option and the input
                                                                                                      	// solution was trained with the User-Personalization
                                                                                                      	// (https://docs.aws.amazon.com/personalize/latest/dg/native-recipe-new-item-USER_PERSONALIZATION.html)
                                                                                                      	// recipe or the HRNN-Coldstart
                                                                                                      	// (https://docs.aws.amazon.com/personalize/latest/dg/native-recipe-hrnn-coldstart.html)
                                                                                                      	// recipe.
                                                                                                      	TrainingMode types.TrainingMode
                                                                                                      }

                                                                                                      type CreateSolutionVersionOutput

                                                                                                      type CreateSolutionVersionOutput struct {
                                                                                                      
                                                                                                      	// The ARN of the new solution version.
                                                                                                      	SolutionVersionArn *string
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type DeleteCampaignInput

                                                                                                      type DeleteCampaignInput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the campaign to delete.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	CampaignArn *string
                                                                                                      }

                                                                                                      type DeleteCampaignOutput

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

                                                                                                      type DeleteDatasetGroupInput

                                                                                                      type DeleteDatasetGroupInput struct {
                                                                                                      
                                                                                                      	// The ARN of the dataset group to delete.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	DatasetGroupArn *string
                                                                                                      }

                                                                                                      type DeleteDatasetGroupOutput

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

                                                                                                      type DeleteDatasetInput

                                                                                                      type DeleteDatasetInput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the dataset to delete.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	DatasetArn *string
                                                                                                      }

                                                                                                      type DeleteDatasetOutput

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

                                                                                                      type DeleteEventTrackerInput

                                                                                                      type DeleteEventTrackerInput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the event tracker to delete.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	EventTrackerArn *string
                                                                                                      }

                                                                                                      type DeleteEventTrackerOutput

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

                                                                                                      type DeleteFilterInput

                                                                                                      type DeleteFilterInput struct {
                                                                                                      
                                                                                                      	// The ARN of the filter to delete.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	FilterArn *string
                                                                                                      }

                                                                                                      type DeleteFilterOutput

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

                                                                                                      type DeleteSchemaInput

                                                                                                      type DeleteSchemaInput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the schema to delete.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	SchemaArn *string
                                                                                                      }

                                                                                                      type DeleteSchemaOutput

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

                                                                                                      type DeleteSolutionInput

                                                                                                      type DeleteSolutionInput struct {
                                                                                                      
                                                                                                      	// The ARN of the solution to delete.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	SolutionArn *string
                                                                                                      }

                                                                                                      type DeleteSolutionOutput

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

                                                                                                      type DescribeAlgorithmInput

                                                                                                      type DescribeAlgorithmInput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the algorithm to describe.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	AlgorithmArn *string
                                                                                                      }

                                                                                                      type DescribeAlgorithmOutput

                                                                                                      type DescribeAlgorithmOutput struct {
                                                                                                      
                                                                                                      	// A listing of the properties of the algorithm.
                                                                                                      	Algorithm *types.Algorithm
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type DescribeBatchInferenceJobInput

                                                                                                      type DescribeBatchInferenceJobInput struct {
                                                                                                      
                                                                                                      	// The ARN of the batch inference job to describe.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	BatchInferenceJobArn *string
                                                                                                      }

                                                                                                      type DescribeBatchInferenceJobOutput

                                                                                                      type DescribeBatchInferenceJobOutput struct {
                                                                                                      
                                                                                                      	// Information on the specified batch inference job.
                                                                                                      	BatchInferenceJob *types.BatchInferenceJob
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type DescribeCampaignInput

                                                                                                      type DescribeCampaignInput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the campaign.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	CampaignArn *string
                                                                                                      }

                                                                                                      type DescribeCampaignOutput

                                                                                                      type DescribeCampaignOutput struct {
                                                                                                      
                                                                                                      	// The properties of the campaign.
                                                                                                      	Campaign *types.Campaign
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type DescribeDatasetGroupInput

                                                                                                      type DescribeDatasetGroupInput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the dataset group to describe.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	DatasetGroupArn *string
                                                                                                      }

                                                                                                      type DescribeDatasetGroupOutput

                                                                                                      type DescribeDatasetGroupOutput struct {
                                                                                                      
                                                                                                      	// A listing of the dataset group's properties.
                                                                                                      	DatasetGroup *types.DatasetGroup
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type DescribeDatasetImportJobInput

                                                                                                      type DescribeDatasetImportJobInput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the dataset import job to describe.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	DatasetImportJobArn *string
                                                                                                      }

                                                                                                      type DescribeDatasetImportJobOutput

                                                                                                      type DescribeDatasetImportJobOutput struct {
                                                                                                      
                                                                                                      	// Information about the dataset import job, including the status. The status is
                                                                                                      	// one of the following values:
                                                                                                      	//
                                                                                                      	// * CREATE PENDING
                                                                                                      	//
                                                                                                      	// * CREATE IN_PROGRESS
                                                                                                      	//
                                                                                                      	// *
                                                                                                      	// ACTIVE
                                                                                                      	//
                                                                                                      	// * CREATE FAILED
                                                                                                      	DatasetImportJob *types.DatasetImportJob
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type DescribeDatasetInput

                                                                                                      type DescribeDatasetInput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the dataset to describe.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	DatasetArn *string
                                                                                                      }

                                                                                                      type DescribeDatasetOutput

                                                                                                      type DescribeDatasetOutput struct {
                                                                                                      
                                                                                                      	// A listing of the dataset's properties.
                                                                                                      	Dataset *types.Dataset
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type DescribeEventTrackerInput

                                                                                                      type DescribeEventTrackerInput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the event tracker to describe.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	EventTrackerArn *string
                                                                                                      }

                                                                                                      type DescribeEventTrackerOutput

                                                                                                      type DescribeEventTrackerOutput struct {
                                                                                                      
                                                                                                      	// An object that describes the event tracker.
                                                                                                      	EventTracker *types.EventTracker
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type DescribeFeatureTransformationInput

                                                                                                      type DescribeFeatureTransformationInput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the feature transformation to describe.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	FeatureTransformationArn *string
                                                                                                      }

                                                                                                      type DescribeFeatureTransformationOutput

                                                                                                      type DescribeFeatureTransformationOutput struct {
                                                                                                      
                                                                                                      	// A listing of the FeatureTransformation properties.
                                                                                                      	FeatureTransformation *types.FeatureTransformation
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type DescribeFilterInput

                                                                                                      type DescribeFilterInput struct {
                                                                                                      
                                                                                                      	// The ARN of the filter to describe.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	FilterArn *string
                                                                                                      }

                                                                                                      type DescribeFilterOutput

                                                                                                      type DescribeFilterOutput struct {
                                                                                                      
                                                                                                      	// The filter's details.
                                                                                                      	Filter *types.Filter
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type DescribeRecipeInput

                                                                                                      type DescribeRecipeInput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the recipe to describe.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	RecipeArn *string
                                                                                                      }

                                                                                                      type DescribeRecipeOutput

                                                                                                      type DescribeRecipeOutput struct {
                                                                                                      
                                                                                                      	// An object that describes the recipe.
                                                                                                      	Recipe *types.Recipe
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type DescribeSchemaInput

                                                                                                      type DescribeSchemaInput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the schema to retrieve.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	SchemaArn *string
                                                                                                      }

                                                                                                      type DescribeSchemaOutput

                                                                                                      type DescribeSchemaOutput struct {
                                                                                                      
                                                                                                      	// The requested schema.
                                                                                                      	Schema *types.DatasetSchema
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type DescribeSolutionInput

                                                                                                      type DescribeSolutionInput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the solution to describe.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	SolutionArn *string
                                                                                                      }

                                                                                                      type DescribeSolutionOutput

                                                                                                      type DescribeSolutionOutput struct {
                                                                                                      
                                                                                                      	// An object that describes the solution.
                                                                                                      	Solution *types.Solution
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type DescribeSolutionVersionInput

                                                                                                      type DescribeSolutionVersionInput struct {
                                                                                                      
                                                                                                      	// The Amazon Resource Name (ARN) of the solution version.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	SolutionVersionArn *string
                                                                                                      }

                                                                                                      type DescribeSolutionVersionOutput

                                                                                                      type DescribeSolutionVersionOutput struct {
                                                                                                      
                                                                                                      	// The solution version.
                                                                                                      	SolutionVersion *types.SolutionVersion
                                                                                                      
                                                                                                      	// 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 GetSolutionMetricsInput

                                                                                                              type GetSolutionMetricsInput struct {
                                                                                                              
                                                                                                              	// The Amazon Resource Name (ARN) of the solution version for which to get metrics.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	SolutionVersionArn *string
                                                                                                              }

                                                                                                              type GetSolutionMetricsOutput

                                                                                                              type GetSolutionMetricsOutput struct {
                                                                                                              
                                                                                                              	// The metrics for the solution version.
                                                                                                              	Metrics map[string]float64
                                                                                                              
                                                                                                              	// The same solution version ARN as specified in the request.
                                                                                                              	SolutionVersionArn *string
                                                                                                              
                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                              }

                                                                                                              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 ListBatchInferenceJobsAPIClient

                                                                                                              type ListBatchInferenceJobsAPIClient interface {
                                                                                                              	ListBatchInferenceJobs(context.Context, *ListBatchInferenceJobsInput, ...func(*Options)) (*ListBatchInferenceJobsOutput, error)
                                                                                                              }

                                                                                                                ListBatchInferenceJobsAPIClient is a client that implements the ListBatchInferenceJobs operation.

                                                                                                                type ListBatchInferenceJobsInput

                                                                                                                type ListBatchInferenceJobsInput struct {
                                                                                                                
                                                                                                                	// The maximum number of batch inference job results to return in each page. The
                                                                                                                	// default value is 100.
                                                                                                                	MaxResults *int32
                                                                                                                
                                                                                                                	// The token to request the next page of results.
                                                                                                                	NextToken *string
                                                                                                                
                                                                                                                	// The Amazon Resource Name (ARN) of the solution version from which the batch
                                                                                                                	// inference jobs were created.
                                                                                                                	SolutionVersionArn *string
                                                                                                                }

                                                                                                                type ListBatchInferenceJobsOutput

                                                                                                                type ListBatchInferenceJobsOutput struct {
                                                                                                                
                                                                                                                	// A list containing information on each job that is returned.
                                                                                                                	BatchInferenceJobs []types.BatchInferenceJobSummary
                                                                                                                
                                                                                                                	// The token to use to retreive the next page of results. The value is null when
                                                                                                                	// there are no more results to return.
                                                                                                                	NextToken *string
                                                                                                                
                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                }

                                                                                                                type ListBatchInferenceJobsPaginator

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

                                                                                                                  ListBatchInferenceJobsPaginator is a paginator for ListBatchInferenceJobs

                                                                                                                  func NewListBatchInferenceJobsPaginator

                                                                                                                    NewListBatchInferenceJobsPaginator returns a new ListBatchInferenceJobsPaginator

                                                                                                                    func (*ListBatchInferenceJobsPaginator) HasMorePages

                                                                                                                    func (p *ListBatchInferenceJobsPaginator) HasMorePages() bool

                                                                                                                      HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                      func (*ListBatchInferenceJobsPaginator) NextPage

                                                                                                                        NextPage retrieves the next ListBatchInferenceJobs page.

                                                                                                                        type ListBatchInferenceJobsPaginatorOptions

                                                                                                                        type ListBatchInferenceJobsPaginatorOptions struct {
                                                                                                                        	// The maximum number of batch inference job results to return in each page. The
                                                                                                                        	// default value is 100.
                                                                                                                        	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
                                                                                                                        }

                                                                                                                          ListBatchInferenceJobsPaginatorOptions is the paginator options for ListBatchInferenceJobs

                                                                                                                          type ListCampaignsAPIClient

                                                                                                                          type ListCampaignsAPIClient interface {
                                                                                                                          	ListCampaigns(context.Context, *ListCampaignsInput, ...func(*Options)) (*ListCampaignsOutput, error)
                                                                                                                          }

                                                                                                                            ListCampaignsAPIClient is a client that implements the ListCampaigns operation.

                                                                                                                            type ListCampaignsInput

                                                                                                                            type ListCampaignsInput struct {
                                                                                                                            
                                                                                                                            	// The maximum number of campaigns to return.
                                                                                                                            	MaxResults *int32
                                                                                                                            
                                                                                                                            	// A token returned from the previous call to ListCampaigns for getting the next
                                                                                                                            	// set of campaigns (if they exist).
                                                                                                                            	NextToken *string
                                                                                                                            
                                                                                                                            	// The Amazon Resource Name (ARN) of the solution to list the campaigns for. When a
                                                                                                                            	// solution is not specified, all the campaigns associated with the account are
                                                                                                                            	// listed.
                                                                                                                            	SolutionArn *string
                                                                                                                            }

                                                                                                                            type ListCampaignsOutput

                                                                                                                            type ListCampaignsOutput struct {
                                                                                                                            
                                                                                                                            	// A list of the campaigns.
                                                                                                                            	Campaigns []types.CampaignSummary
                                                                                                                            
                                                                                                                            	// A token for getting the next set of campaigns (if they exist).
                                                                                                                            	NextToken *string
                                                                                                                            
                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                            }

                                                                                                                            type ListCampaignsPaginator

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

                                                                                                                              ListCampaignsPaginator is a paginator for ListCampaigns

                                                                                                                              func NewListCampaignsPaginator

                                                                                                                              func NewListCampaignsPaginator(client ListCampaignsAPIClient, params *ListCampaignsInput, optFns ...func(*ListCampaignsPaginatorOptions)) *ListCampaignsPaginator

                                                                                                                                NewListCampaignsPaginator returns a new ListCampaignsPaginator

                                                                                                                                func (*ListCampaignsPaginator) HasMorePages

                                                                                                                                func (p *ListCampaignsPaginator) HasMorePages() bool

                                                                                                                                  HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                  func (*ListCampaignsPaginator) NextPage

                                                                                                                                  func (p *ListCampaignsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListCampaignsOutput, error)

                                                                                                                                    NextPage retrieves the next ListCampaigns page.

                                                                                                                                    type ListCampaignsPaginatorOptions

                                                                                                                                    type ListCampaignsPaginatorOptions struct {
                                                                                                                                    	// The maximum number of campaigns to return.
                                                                                                                                    	Limit int32
                                                                                                                                    
                                                                                                                                    	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                    	// that matches the most recent token provided to the service.
                                                                                                                                    	StopOnDuplicateToken bool
                                                                                                                                    }

                                                                                                                                      ListCampaignsPaginatorOptions is the paginator options for ListCampaigns

                                                                                                                                      type ListDatasetGroupsAPIClient

                                                                                                                                      type ListDatasetGroupsAPIClient interface {
                                                                                                                                      	ListDatasetGroups(context.Context, *ListDatasetGroupsInput, ...func(*Options)) (*ListDatasetGroupsOutput, error)
                                                                                                                                      }

                                                                                                                                        ListDatasetGroupsAPIClient is a client that implements the ListDatasetGroups operation.

                                                                                                                                        type ListDatasetGroupsInput

                                                                                                                                        type ListDatasetGroupsInput struct {
                                                                                                                                        
                                                                                                                                        	// The maximum number of dataset groups to return.
                                                                                                                                        	MaxResults *int32
                                                                                                                                        
                                                                                                                                        	// A token returned from the previous call to ListDatasetGroups for getting the
                                                                                                                                        	// next set of dataset groups (if they exist).
                                                                                                                                        	NextToken *string
                                                                                                                                        }

                                                                                                                                        type ListDatasetGroupsOutput

                                                                                                                                        type ListDatasetGroupsOutput struct {
                                                                                                                                        
                                                                                                                                        	// The list of your dataset groups.
                                                                                                                                        	DatasetGroups []types.DatasetGroupSummary
                                                                                                                                        
                                                                                                                                        	// A token for getting the next set of dataset groups (if they exist).
                                                                                                                                        	NextToken *string
                                                                                                                                        
                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                        }

                                                                                                                                        type ListDatasetGroupsPaginator

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

                                                                                                                                          ListDatasetGroupsPaginator is a paginator for ListDatasetGroups

                                                                                                                                          func NewListDatasetGroupsPaginator

                                                                                                                                          func NewListDatasetGroupsPaginator(client ListDatasetGroupsAPIClient, params *ListDatasetGroupsInput, optFns ...func(*ListDatasetGroupsPaginatorOptions)) *ListDatasetGroupsPaginator

                                                                                                                                            NewListDatasetGroupsPaginator returns a new ListDatasetGroupsPaginator

                                                                                                                                            func (*ListDatasetGroupsPaginator) HasMorePages

                                                                                                                                            func (p *ListDatasetGroupsPaginator) HasMorePages() bool

                                                                                                                                              HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                              func (*ListDatasetGroupsPaginator) NextPage

                                                                                                                                              func (p *ListDatasetGroupsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDatasetGroupsOutput, error)

                                                                                                                                                NextPage retrieves the next ListDatasetGroups page.

                                                                                                                                                type ListDatasetGroupsPaginatorOptions

                                                                                                                                                type ListDatasetGroupsPaginatorOptions struct {
                                                                                                                                                	// The maximum number of dataset groups to return.
                                                                                                                                                	Limit int32
                                                                                                                                                
                                                                                                                                                	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                	// that matches the most recent token provided to the service.
                                                                                                                                                	StopOnDuplicateToken bool
                                                                                                                                                }

                                                                                                                                                  ListDatasetGroupsPaginatorOptions is the paginator options for ListDatasetGroups

                                                                                                                                                  type ListDatasetImportJobsAPIClient

                                                                                                                                                  type ListDatasetImportJobsAPIClient interface {
                                                                                                                                                  	ListDatasetImportJobs(context.Context, *ListDatasetImportJobsInput, ...func(*Options)) (*ListDatasetImportJobsOutput, error)
                                                                                                                                                  }

                                                                                                                                                    ListDatasetImportJobsAPIClient is a client that implements the ListDatasetImportJobs operation.

                                                                                                                                                    type ListDatasetImportJobsInput

                                                                                                                                                    type ListDatasetImportJobsInput struct {
                                                                                                                                                    
                                                                                                                                                    	// The Amazon Resource Name (ARN) of the dataset to list the dataset import jobs
                                                                                                                                                    	// for.
                                                                                                                                                    	DatasetArn *string
                                                                                                                                                    
                                                                                                                                                    	// The maximum number of dataset import jobs to return.
                                                                                                                                                    	MaxResults *int32
                                                                                                                                                    
                                                                                                                                                    	// A token returned from the previous call to ListDatasetImportJobs for getting the
                                                                                                                                                    	// next set of dataset import jobs (if they exist).
                                                                                                                                                    	NextToken *string
                                                                                                                                                    }

                                                                                                                                                    type ListDatasetImportJobsOutput

                                                                                                                                                    type ListDatasetImportJobsOutput struct {
                                                                                                                                                    
                                                                                                                                                    	// The list of dataset import jobs.
                                                                                                                                                    	DatasetImportJobs []types.DatasetImportJobSummary
                                                                                                                                                    
                                                                                                                                                    	// A token for getting the next set of dataset import jobs (if they exist).
                                                                                                                                                    	NextToken *string
                                                                                                                                                    
                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                    }

                                                                                                                                                    type ListDatasetImportJobsPaginator

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

                                                                                                                                                      ListDatasetImportJobsPaginator is a paginator for ListDatasetImportJobs

                                                                                                                                                      func NewListDatasetImportJobsPaginator

                                                                                                                                                        NewListDatasetImportJobsPaginator returns a new ListDatasetImportJobsPaginator

                                                                                                                                                        func (*ListDatasetImportJobsPaginator) HasMorePages

                                                                                                                                                        func (p *ListDatasetImportJobsPaginator) HasMorePages() bool

                                                                                                                                                          HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                          func (*ListDatasetImportJobsPaginator) NextPage

                                                                                                                                                            NextPage retrieves the next ListDatasetImportJobs page.

                                                                                                                                                            type ListDatasetImportJobsPaginatorOptions

                                                                                                                                                            type ListDatasetImportJobsPaginatorOptions struct {
                                                                                                                                                            	// The maximum number of dataset import jobs to return.
                                                                                                                                                            	Limit int32
                                                                                                                                                            
                                                                                                                                                            	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                            	// that matches the most recent token provided to the service.
                                                                                                                                                            	StopOnDuplicateToken bool
                                                                                                                                                            }

                                                                                                                                                              ListDatasetImportJobsPaginatorOptions is the paginator options for ListDatasetImportJobs

                                                                                                                                                              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 Amazon Resource Name (ARN) of the dataset group that contains the datasets
                                                                                                                                                                	// to list.
                                                                                                                                                                	DatasetGroupArn *string
                                                                                                                                                                
                                                                                                                                                                	// The maximum number of datasets to return.
                                                                                                                                                                	MaxResults *int32
                                                                                                                                                                
                                                                                                                                                                	// A token returned from the previous call to ListDatasetImportJobs for getting the
                                                                                                                                                                	// next set of dataset import jobs (if they exist).
                                                                                                                                                                	NextToken *string
                                                                                                                                                                }

                                                                                                                                                                type ListDatasetsOutput

                                                                                                                                                                type ListDatasetsOutput struct {
                                                                                                                                                                
                                                                                                                                                                	// An array of Dataset objects. Each object provides metadata information.
                                                                                                                                                                	Datasets []types.DatasetSummary
                                                                                                                                                                
                                                                                                                                                                	// A token for getting the next set of datasets (if they exist).
                                                                                                                                                                	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 datasets to return.
                                                                                                                                                                        	Limit int32
                                                                                                                                                                        
                                                                                                                                                                        	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                        	// that matches the most recent token provided to the service.
                                                                                                                                                                        	StopOnDuplicateToken bool
                                                                                                                                                                        }

                                                                                                                                                                          ListDatasetsPaginatorOptions is the paginator options for ListDatasets

                                                                                                                                                                          type ListEventTrackersAPIClient

                                                                                                                                                                          type ListEventTrackersAPIClient interface {
                                                                                                                                                                          	ListEventTrackers(context.Context, *ListEventTrackersInput, ...func(*Options)) (*ListEventTrackersOutput, error)
                                                                                                                                                                          }

                                                                                                                                                                            ListEventTrackersAPIClient is a client that implements the ListEventTrackers operation.

                                                                                                                                                                            type ListEventTrackersInput

                                                                                                                                                                            type ListEventTrackersInput struct {
                                                                                                                                                                            
                                                                                                                                                                            	// The ARN of a dataset group used to filter the response.
                                                                                                                                                                            	DatasetGroupArn *string
                                                                                                                                                                            
                                                                                                                                                                            	// The maximum number of event trackers to return.
                                                                                                                                                                            	MaxResults *int32
                                                                                                                                                                            
                                                                                                                                                                            	// A token returned from the previous call to ListEventTrackers for getting the
                                                                                                                                                                            	// next set of event trackers (if they exist).
                                                                                                                                                                            	NextToken *string
                                                                                                                                                                            }

                                                                                                                                                                            type ListEventTrackersOutput

                                                                                                                                                                            type ListEventTrackersOutput struct {
                                                                                                                                                                            
                                                                                                                                                                            	// A list of event trackers.
                                                                                                                                                                            	EventTrackers []types.EventTrackerSummary
                                                                                                                                                                            
                                                                                                                                                                            	// A token for getting the next set of event trackers (if they exist).
                                                                                                                                                                            	NextToken *string
                                                                                                                                                                            
                                                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                                                            }

                                                                                                                                                                            type ListEventTrackersPaginator

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

                                                                                                                                                                              ListEventTrackersPaginator is a paginator for ListEventTrackers

                                                                                                                                                                              func NewListEventTrackersPaginator

                                                                                                                                                                              func NewListEventTrackersPaginator(client ListEventTrackersAPIClient, params *ListEventTrackersInput, optFns ...func(*ListEventTrackersPaginatorOptions)) *ListEventTrackersPaginator

                                                                                                                                                                                NewListEventTrackersPaginator returns a new ListEventTrackersPaginator

                                                                                                                                                                                func (*ListEventTrackersPaginator) HasMorePages

                                                                                                                                                                                func (p *ListEventTrackersPaginator) HasMorePages() bool

                                                                                                                                                                                  HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                                  func (*ListEventTrackersPaginator) NextPage

                                                                                                                                                                                  func (p *ListEventTrackersPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListEventTrackersOutput, error)

                                                                                                                                                                                    NextPage retrieves the next ListEventTrackers page.

                                                                                                                                                                                    type ListEventTrackersPaginatorOptions

                                                                                                                                                                                    type ListEventTrackersPaginatorOptions struct {
                                                                                                                                                                                    	// The maximum number of event trackers to return.
                                                                                                                                                                                    	Limit int32
                                                                                                                                                                                    
                                                                                                                                                                                    	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                                    	// that matches the most recent token provided to the service.
                                                                                                                                                                                    	StopOnDuplicateToken bool
                                                                                                                                                                                    }

                                                                                                                                                                                      ListEventTrackersPaginatorOptions is the paginator options for ListEventTrackers

                                                                                                                                                                                      type ListFiltersInput

                                                                                                                                                                                      type ListFiltersInput struct {
                                                                                                                                                                                      
                                                                                                                                                                                      	// The ARN of the dataset group that contains the filters.
                                                                                                                                                                                      	DatasetGroupArn *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// The maximum number of filters to return.
                                                                                                                                                                                      	MaxResults *int32
                                                                                                                                                                                      
                                                                                                                                                                                      	// A token returned from the previous call to ListFilters for getting the next set
                                                                                                                                                                                      	// of filters (if they exist).
                                                                                                                                                                                      	NextToken *string
                                                                                                                                                                                      }

                                                                                                                                                                                      type ListFiltersOutput

                                                                                                                                                                                      type ListFiltersOutput struct {
                                                                                                                                                                                      
                                                                                                                                                                                      	// A list of returned filters.
                                                                                                                                                                                      	Filters []types.FilterSummary
                                                                                                                                                                                      
                                                                                                                                                                                      	// A token for getting the next set of filters (if they exist).
                                                                                                                                                                                      	NextToken *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                                                      }

                                                                                                                                                                                      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 recipes to return.
                                                                                                                                                                                        	MaxResults *int32
                                                                                                                                                                                        
                                                                                                                                                                                        	// A token returned from the previous call to ListRecipes for getting the next set
                                                                                                                                                                                        	// of recipes (if they exist).
                                                                                                                                                                                        	NextToken *string
                                                                                                                                                                                        
                                                                                                                                                                                        	// The default is SERVICE.
                                                                                                                                                                                        	RecipeProvider types.RecipeProvider
                                                                                                                                                                                        }

                                                                                                                                                                                        type ListRecipesOutput

                                                                                                                                                                                        type ListRecipesOutput struct {
                                                                                                                                                                                        
                                                                                                                                                                                        	// A token for getting the next set of recipes.
                                                                                                                                                                                        	NextToken *string
                                                                                                                                                                                        
                                                                                                                                                                                        	// The list of available recipes.
                                                                                                                                                                                        	Recipes []types.RecipeSummary
                                                                                                                                                                                        
                                                                                                                                                                                        	// 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 recipes to return.
                                                                                                                                                                                                	Limit int32
                                                                                                                                                                                                
                                                                                                                                                                                                	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                                                	// that matches the most recent token provided to the service.
                                                                                                                                                                                                	StopOnDuplicateToken bool
                                                                                                                                                                                                }

                                                                                                                                                                                                  ListRecipesPaginatorOptions is the paginator options for ListRecipes

                                                                                                                                                                                                  type ListSchemasAPIClient

                                                                                                                                                                                                  type ListSchemasAPIClient interface {
                                                                                                                                                                                                  	ListSchemas(context.Context, *ListSchemasInput, ...func(*Options)) (*ListSchemasOutput, error)
                                                                                                                                                                                                  }

                                                                                                                                                                                                    ListSchemasAPIClient is a client that implements the ListSchemas operation.

                                                                                                                                                                                                    type ListSchemasInput

                                                                                                                                                                                                    type ListSchemasInput struct {
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The maximum number of schemas to return.
                                                                                                                                                                                                    	MaxResults *int32
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// A token returned from the previous call to ListSchemas for getting the next set
                                                                                                                                                                                                    	// of schemas (if they exist).
                                                                                                                                                                                                    	NextToken *string
                                                                                                                                                                                                    }

                                                                                                                                                                                                    type ListSchemasOutput

                                                                                                                                                                                                    type ListSchemasOutput struct {
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// A token used to get the next set of schemas (if they exist).
                                                                                                                                                                                                    	NextToken *string
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// A list of schemas.
                                                                                                                                                                                                    	Schemas []types.DatasetSchemaSummary
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                                                                    }

                                                                                                                                                                                                    type ListSchemasPaginator

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

                                                                                                                                                                                                      ListSchemasPaginator is a paginator for ListSchemas

                                                                                                                                                                                                      func NewListSchemasPaginator

                                                                                                                                                                                                      func NewListSchemasPaginator(client ListSchemasAPIClient, params *ListSchemasInput, optFns ...func(*ListSchemasPaginatorOptions)) *ListSchemasPaginator

                                                                                                                                                                                                        NewListSchemasPaginator returns a new ListSchemasPaginator

                                                                                                                                                                                                        func (*ListSchemasPaginator) HasMorePages

                                                                                                                                                                                                        func (p *ListSchemasPaginator) HasMorePages() bool

                                                                                                                                                                                                          HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                                                          func (*ListSchemasPaginator) NextPage

                                                                                                                                                                                                          func (p *ListSchemasPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListSchemasOutput, error)

                                                                                                                                                                                                            NextPage retrieves the next ListSchemas page.

                                                                                                                                                                                                            type ListSchemasPaginatorOptions

                                                                                                                                                                                                            type ListSchemasPaginatorOptions struct {
                                                                                                                                                                                                            	// The maximum number of schemas to return.
                                                                                                                                                                                                            	Limit int32
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                                                            	// that matches the most recent token provided to the service.
                                                                                                                                                                                                            	StopOnDuplicateToken bool
                                                                                                                                                                                                            }

                                                                                                                                                                                                              ListSchemasPaginatorOptions is the paginator options for ListSchemas

                                                                                                                                                                                                              type ListSolutionVersionsAPIClient

                                                                                                                                                                                                              type ListSolutionVersionsAPIClient interface {
                                                                                                                                                                                                              	ListSolutionVersions(context.Context, *ListSolutionVersionsInput, ...func(*Options)) (*ListSolutionVersionsOutput, error)
                                                                                                                                                                                                              }

                                                                                                                                                                                                                ListSolutionVersionsAPIClient is a client that implements the ListSolutionVersions operation.

                                                                                                                                                                                                                type ListSolutionVersionsInput

                                                                                                                                                                                                                type ListSolutionVersionsInput struct {
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// The maximum number of solution versions to return.
                                                                                                                                                                                                                	MaxResults *int32
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// A token returned from the previous call to ListSolutionVersions for getting the
                                                                                                                                                                                                                	// next set of solution versions (if they exist).
                                                                                                                                                                                                                	NextToken *string
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// The Amazon Resource Name (ARN) of the solution.
                                                                                                                                                                                                                	SolutionArn *string
                                                                                                                                                                                                                }

                                                                                                                                                                                                                type ListSolutionVersionsOutput

                                                                                                                                                                                                                type ListSolutionVersionsOutput struct {
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// A token for getting the next set of solution versions (if they exist).
                                                                                                                                                                                                                	NextToken *string
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// A list of solution versions describing the version properties.
                                                                                                                                                                                                                	SolutionVersions []types.SolutionVersionSummary
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                }

                                                                                                                                                                                                                type ListSolutionVersionsPaginator

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

                                                                                                                                                                                                                  ListSolutionVersionsPaginator is a paginator for ListSolutionVersions

                                                                                                                                                                                                                  func NewListSolutionVersionsPaginator

                                                                                                                                                                                                                    NewListSolutionVersionsPaginator returns a new ListSolutionVersionsPaginator

                                                                                                                                                                                                                    func (*ListSolutionVersionsPaginator) HasMorePages

                                                                                                                                                                                                                    func (p *ListSolutionVersionsPaginator) HasMorePages() bool

                                                                                                                                                                                                                      HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                                                                      func (*ListSolutionVersionsPaginator) NextPage

                                                                                                                                                                                                                        NextPage retrieves the next ListSolutionVersions page.

                                                                                                                                                                                                                        type ListSolutionVersionsPaginatorOptions

                                                                                                                                                                                                                        type ListSolutionVersionsPaginatorOptions struct {
                                                                                                                                                                                                                        	// The maximum number of solution versions to return.
                                                                                                                                                                                                                        	Limit int32
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                                                                        	// that matches the most recent token provided to the service.
                                                                                                                                                                                                                        	StopOnDuplicateToken bool
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                          ListSolutionVersionsPaginatorOptions is the paginator options for ListSolutionVersions

                                                                                                                                                                                                                          type ListSolutionsAPIClient

                                                                                                                                                                                                                          type ListSolutionsAPIClient interface {
                                                                                                                                                                                                                          	ListSolutions(context.Context, *ListSolutionsInput, ...func(*Options)) (*ListSolutionsOutput, error)
                                                                                                                                                                                                                          }

                                                                                                                                                                                                                            ListSolutionsAPIClient is a client that implements the ListSolutions operation.

                                                                                                                                                                                                                            type ListSolutionsInput

                                                                                                                                                                                                                            type ListSolutionsInput struct {
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// The Amazon Resource Name (ARN) of the dataset group.
                                                                                                                                                                                                                            	DatasetGroupArn *string
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// The maximum number of solutions to return.
                                                                                                                                                                                                                            	MaxResults *int32
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// A token returned from the previous call to ListSolutions for getting the next
                                                                                                                                                                                                                            	// set of solutions (if they exist).
                                                                                                                                                                                                                            	NextToken *string
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                            type ListSolutionsOutput

                                                                                                                                                                                                                            type ListSolutionsOutput struct {
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// A token for getting the next set of solutions (if they exist).
                                                                                                                                                                                                                            	NextToken *string
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// A list of the current solutions.
                                                                                                                                                                                                                            	Solutions []types.SolutionSummary
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                            type ListSolutionsPaginator

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

                                                                                                                                                                                                                              ListSolutionsPaginator is a paginator for ListSolutions

                                                                                                                                                                                                                              func NewListSolutionsPaginator

                                                                                                                                                                                                                              func NewListSolutionsPaginator(client ListSolutionsAPIClient, params *ListSolutionsInput, optFns ...func(*ListSolutionsPaginatorOptions)) *ListSolutionsPaginator

                                                                                                                                                                                                                                NewListSolutionsPaginator returns a new ListSolutionsPaginator

                                                                                                                                                                                                                                func (*ListSolutionsPaginator) HasMorePages

                                                                                                                                                                                                                                func (p *ListSolutionsPaginator) HasMorePages() bool

                                                                                                                                                                                                                                  HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                                                                                  func (*ListSolutionsPaginator) NextPage

                                                                                                                                                                                                                                  func (p *ListSolutionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListSolutionsOutput, error)

                                                                                                                                                                                                                                    NextPage retrieves the next ListSolutions page.

                                                                                                                                                                                                                                    type ListSolutionsPaginatorOptions

                                                                                                                                                                                                                                    type ListSolutionsPaginatorOptions struct {
                                                                                                                                                                                                                                    	// The maximum number of solutions to return.
                                                                                                                                                                                                                                    	Limit int32
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                                                                                    	// that matches the most recent token provided to the service.
                                                                                                                                                                                                                                    	StopOnDuplicateToken bool
                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                      ListSolutionsPaginatorOptions is the paginator options for ListSolutions

                                                                                                                                                                                                                                      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 ResolveEndpoint

                                                                                                                                                                                                                                        type ResolveEndpoint struct {
                                                                                                                                                                                                                                        	Resolver EndpointResolver
                                                                                                                                                                                                                                        	Options  EndpointResolverOptions
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                        func (*ResolveEndpoint) HandleSerialize

                                                                                                                                                                                                                                        func (*ResolveEndpoint) ID

                                                                                                                                                                                                                                        func (*ResolveEndpoint) ID() string

                                                                                                                                                                                                                                        type UpdateCampaignInput

                                                                                                                                                                                                                                        type UpdateCampaignInput struct {
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// The Amazon Resource Name (ARN) of the campaign.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                        	CampaignArn *string
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// The configuration details of a campaign.
                                                                                                                                                                                                                                        	CampaignConfig *types.CampaignConfig
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// Specifies the requested minimum provisioned transactions (recommendations) per
                                                                                                                                                                                                                                        	// second that Amazon Personalize will support.
                                                                                                                                                                                                                                        	MinProvisionedTPS *int32
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// The ARN of a new solution version to deploy.
                                                                                                                                                                                                                                        	SolutionVersionArn *string
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                        type UpdateCampaignOutput

                                                                                                                                                                                                                                        type UpdateCampaignOutput struct {
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// The same campaign ARN as given in the request.
                                                                                                                                                                                                                                        	CampaignArn *string
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                        Directories

                                                                                                                                                                                                                                        Path Synopsis
                                                                                                                                                                                                                                        internal