From 312e442dc8e12c6cb311e8ac5fcb5560eb4bcee1 Mon Sep 17 00:00:00 2001 From: AWS SDK for Go v2 automation user Date: Tue, 2 May 2023 18:16:26 +0000 Subject: [PATCH] Regenerated Clients --- .../12a4cce28df54111a2ccd32eab6bbec6.json | 8 + .../3321ef9f9f27454f842c781144235c14.json | 8 + .../9517aa70d2764a168b4dd1dc57ee44dc.json | 8 + .../b6d1645dad484ff08c80cda0011863e3.json | 8 + .../d748a8d632ba4e748b3dd7220cd8dab1.json | 8 + .../efefdac4ec9347c9b2604af69a3049be.json | 8 + .../appflow/api_op_CancelFlowExecutions.go | 145 ++++++++++ service/appflow/deserializers.go | 195 +++++++++++++ service/appflow/generated.json | 1 + service/appflow/serializers.go | 86 ++++++ service/appflow/types/enums.go | 10 +- service/appflow/validators.go | 39 +++ service/connect/types/enums.go | 2 + service/ecs/api_op_PutAccountSetting.go | 2 +- .../ecs/api_op_PutAccountSettingDefault.go | 2 +- .../internal/endpoints/endpoints.go | 35 --- .../api_op_CreateQuerySuggestionsBlockList.go | 2 +- .../api_op_DescribeQuerySuggestionsConfig.go | 14 +- service/kendra/api_op_GetQuerySuggestions.go | 13 + .../kendra/api_op_UpdateFeaturedResultsSet.go | 2 +- .../api_op_UpdateQuerySuggestionsConfig.go | 14 +- service/kendra/deserializers.go | 258 ++++++++++++++++++ service/kendra/serializers.go | 116 ++++++++ service/kendra/types/enums.go | 36 +++ service/kendra/types/types.go | 106 +++++++ service/kendra/validators.go | 27 ++ service/resiliencehub/api_op_CreateApp.go | 18 +- .../api_op_CreateAppVersionResource.go | 8 +- service/resiliencehub/deserializers.go | 18 ++ service/resiliencehub/types/enums.go | 18 ++ service/resiliencehub/types/types.go | 6 + service/resiliencehub/validators.go | 3 - service/sagemaker/deserializers.go | 9 + service/sagemaker/serializers.go | 5 + service/sagemaker/types/types.go | 113 ++------ .../signer/internal/endpoints/endpoints.go | 130 +++++++++ 36 files changed, 1319 insertions(+), 162 deletions(-) create mode 100644 .changelog/12a4cce28df54111a2ccd32eab6bbec6.json create mode 100644 .changelog/3321ef9f9f27454f842c781144235c14.json create mode 100644 .changelog/9517aa70d2764a168b4dd1dc57ee44dc.json create mode 100644 .changelog/b6d1645dad484ff08c80cda0011863e3.json create mode 100644 .changelog/d748a8d632ba4e748b3dd7220cd8dab1.json create mode 100644 .changelog/efefdac4ec9347c9b2604af69a3049be.json create mode 100644 service/appflow/api_op_CancelFlowExecutions.go diff --git a/.changelog/12a4cce28df54111a2ccd32eab6bbec6.json b/.changelog/12a4cce28df54111a2ccd32eab6bbec6.json new file mode 100644 index 00000000000..9509ee7fad7 --- /dev/null +++ b/.changelog/12a4cce28df54111a2ccd32eab6bbec6.json @@ -0,0 +1,8 @@ +{ + "id": "12a4cce2-8df5-4111-a2cc-d32eab6bbec6", + "type": "feature", + "description": "This release will improve resource level transparency in applications by discovering previously hidden resources.", + "modules": [ + "service/resiliencehub" + ] +} \ No newline at end of file diff --git a/.changelog/3321ef9f9f27454f842c781144235c14.json b/.changelog/3321ef9f9f27454f842c781144235c14.json new file mode 100644 index 00000000000..12e62a57e70 --- /dev/null +++ b/.changelog/3321ef9f9f27454f842c781144235c14.json @@ -0,0 +1,8 @@ +{ + "id": "3321ef9f-9f27-454f-842c-781144235c14", + "type": "feature", + "description": "This release adds new API to cancel flow executions.", + "modules": [ + "service/appflow" + ] +} \ No newline at end of file diff --git a/.changelog/9517aa70d2764a168b4dd1dc57ee44dc.json b/.changelog/9517aa70d2764a168b4dd1dc57ee44dc.json new file mode 100644 index 00000000000..379817fec02 --- /dev/null +++ b/.changelog/9517aa70d2764a168b4dd1dc57ee44dc.json @@ -0,0 +1,8 @@ +{ + "id": "9517aa70-d276-4a16-8b4d-d1dc57ee44dc", + "type": "feature", + "description": "AWS Kendra now supports configuring document fields/attributes via the GetQuerySuggestions API. You can now base query suggestions on the contents of document fields.", + "modules": [ + "service/kendra" + ] +} \ No newline at end of file diff --git a/.changelog/b6d1645dad484ff08c80cda0011863e3.json b/.changelog/b6d1645dad484ff08c80cda0011863e3.json new file mode 100644 index 00000000000..c82d620b708 --- /dev/null +++ b/.changelog/b6d1645dad484ff08c80cda0011863e3.json @@ -0,0 +1,8 @@ +{ + "id": "b6d1645d-ad48-4ff0-8c80-cda0011863e3", + "type": "documentation", + "description": "Documentation only update to address Amazon ECS tickets.", + "modules": [ + "service/ecs" + ] +} \ No newline at end of file diff --git a/.changelog/d748a8d632ba4e748b3dd7220cd8dab1.json b/.changelog/d748a8d632ba4e748b3dd7220cd8dab1.json new file mode 100644 index 00000000000..de6716e55de --- /dev/null +++ b/.changelog/d748a8d632ba4e748b3dd7220cd8dab1.json @@ -0,0 +1,8 @@ +{ + "id": "d748a8d6-32ba-4e74-8b3d-d7220cd8dab1", + "type": "feature", + "description": "Amazon Connect Service Rules API update: Added OnContactEvaluationSubmit event source to support user configuring evaluation form rules.", + "modules": [ + "service/connect" + ] +} \ No newline at end of file diff --git a/.changelog/efefdac4ec9347c9b2604af69a3049be.json b/.changelog/efefdac4ec9347c9b2604af69a3049be.json new file mode 100644 index 00000000000..64e32a0dda9 --- /dev/null +++ b/.changelog/efefdac4ec9347c9b2604af69a3049be.json @@ -0,0 +1,8 @@ +{ + "id": "efefdac4-ec93-47c9-b260-4af69a3049be", + "type": "feature", + "description": "Amazon Sagemaker Autopilot supports training models with sample weights and additional objective metrics.", + "modules": [ + "service/sagemaker" + ] +} \ No newline at end of file diff --git a/service/appflow/api_op_CancelFlowExecutions.go b/service/appflow/api_op_CancelFlowExecutions.go new file mode 100644 index 00000000000..78f57042930 --- /dev/null +++ b/service/appflow/api_op_CancelFlowExecutions.go @@ -0,0 +1,145 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package appflow + +import ( + "context" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + "github.com/aws/smithy-go/middleware" + smithyhttp "github.com/aws/smithy-go/transport/http" +) + +// Cancels active runs for a flow. You can cancel all of the active runs for a +// flow, or you can cancel specific runs by providing their IDs. You can cancel a +// flow run only when the run is in progress. You can't cancel a run that has +// already completed or failed. You also can't cancel a run that's scheduled to +// occur but hasn't started yet. To prevent a scheduled run, you can deactivate the +// flow with the StopFlow action. You cannot resume a run after you cancel it. +// When you send your request, the status for each run becomes CancelStarted . When +// the cancellation completes, the status becomes Canceled . When you cancel a run, +// you still incur charges for any data that the run already processed before the +// cancellation. If the run had already written some data to the flow destination, +// then that data remains in the destination. If you configured the flow to use a +// batch API (such as the Salesforce Bulk API 2.0), then the run will finish +// reading or writing its entire batch of data after the cancellation. For these +// operations, the data processing charges for Amazon AppFlow apply. For the +// pricing information, see Amazon AppFlow pricing (http://aws.amazon.com/appflow/pricing/) +// . +func (c *Client) CancelFlowExecutions(ctx context.Context, params *CancelFlowExecutionsInput, optFns ...func(*Options)) (*CancelFlowExecutionsOutput, error) { + if params == nil { + params = &CancelFlowExecutionsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "CancelFlowExecutions", params, optFns, c.addOperationCancelFlowExecutionsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*CancelFlowExecutionsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type CancelFlowExecutionsInput struct { + + // The name of a flow with active runs that you want to cancel. + // + // This member is required. + FlowName *string + + // The ID of each active run to cancel. These runs must belong to the flow you + // specify in your request. If you omit this parameter, your request ends all + // active runs that belong to the flow. + ExecutionIds []string + + noSmithyDocumentSerde +} + +type CancelFlowExecutionsOutput struct { + + // The IDs of runs that Amazon AppFlow couldn't cancel. These runs might be + // ineligible for canceling because they haven't started yet or have already + // completed. + InvalidExecutions []string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (c *Client) addOperationCancelFlowExecutionsMiddlewares(stack *middleware.Stack, options Options) (err error) { + err = stack.Serialize.Add(&awsRestjson1_serializeOpCancelFlowExecutions{}, middleware.After) + if err != nil { + return err + } + err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCancelFlowExecutions{}, middleware.After) + if err != nil { + return err + } + if err = addSetLoggerMiddleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil { + return err + } + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil { + return err + } + if err = addRetryMiddlewares(stack, options); err != nil { + return err + } + if err = addHTTPSignerV4Middleware(stack, options); err != nil { + return err + } + if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil { + return err + } + if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil { + return err + } + if err = addClientUserAgent(stack); err != nil { + return err + } + if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil { + return err + } + if err = addOpCancelFlowExecutionsValidationMiddleware(stack); err != nil { + return err + } + if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCancelFlowExecutions(options.Region), middleware.Before); err != nil { + return err + } + if err = awsmiddleware.AddRecursionDetection(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + return nil +} + +func newServiceMetadataMiddleware_opCancelFlowExecutions(region string) *awsmiddleware.RegisterServiceMetadata { + return &awsmiddleware.RegisterServiceMetadata{ + Region: region, + ServiceID: ServiceID, + SigningName: "appflow", + OperationName: "CancelFlowExecutions", + } +} diff --git a/service/appflow/deserializers.go b/service/appflow/deserializers.go index bb9b1ac7a08..d62a85792f4 100644 --- a/service/appflow/deserializers.go +++ b/service/appflow/deserializers.go @@ -20,6 +20,165 @@ import ( "strings" ) +type awsRestjson1_deserializeOpCancelFlowExecutions struct { +} + +func (*awsRestjson1_deserializeOpCancelFlowExecutions) ID() string { + return "OperationDeserializer" +} + +func (m *awsRestjson1_deserializeOpCancelFlowExecutions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( + out middleware.DeserializeOutput, metadata middleware.Metadata, err error, +) { + out, metadata, err = next.HandleDeserialize(ctx, in) + if err != nil { + return out, metadata, err + } + + response, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + if response.StatusCode < 200 || response.StatusCode >= 300 { + return out, metadata, awsRestjson1_deserializeOpErrorCancelFlowExecutions(response, &metadata) + } + output := &CancelFlowExecutionsOutput{} + out.Result = output + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(response.Body, ringBuffer) + + decoder := json.NewDecoder(body) + decoder.UseNumber() + var shape interface{} + if err := decoder.Decode(&shape); err != nil && err != io.EOF { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return out, metadata, err + } + + err = awsRestjson1_deserializeOpDocumentCancelFlowExecutionsOutput(&output, shape) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + return out, metadata, &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), + Snapshot: snapshot.Bytes(), + } + } + + return out, metadata, err +} + +func awsRestjson1_deserializeOpErrorCancelFlowExecutions(response *smithyhttp.Response, metadata *middleware.Metadata) error { + var errorBuffer bytes.Buffer + if _, err := io.Copy(&errorBuffer, response.Body); err != nil { + return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} + } + errorBody := bytes.NewReader(errorBuffer.Bytes()) + + errorCode := "UnknownError" + errorMessage := errorCode + + headerCode := response.Header.Get("X-Amzn-ErrorType") + if len(headerCode) != 0 { + errorCode = restjson.SanitizeErrorCode(headerCode) + } + + var buff [1024]byte + ringBuffer := smithyio.NewRingBuffer(buff[:]) + + body := io.TeeReader(errorBody, ringBuffer) + decoder := json.NewDecoder(body) + decoder.UseNumber() + jsonCode, message, err := restjson.GetErrorInfo(decoder) + if err != nil { + var snapshot bytes.Buffer + io.Copy(&snapshot, ringBuffer) + err = &smithy.DeserializationError{ + Err: fmt.Errorf("failed to decode response body, %w", err), + Snapshot: snapshot.Bytes(), + } + return err + } + + errorBody.Seek(0, io.SeekStart) + if len(headerCode) == 0 && len(jsonCode) != 0 { + errorCode = restjson.SanitizeErrorCode(jsonCode) + } + if len(message) != 0 { + errorMessage = message + } + + switch { + case strings.EqualFold("AccessDeniedException", errorCode): + return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) + + case strings.EqualFold("InternalServerException", errorCode): + return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) + + case strings.EqualFold("ResourceNotFoundException", errorCode): + return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) + + case strings.EqualFold("ThrottlingException", errorCode): + return awsRestjson1_deserializeErrorThrottlingException(response, errorBody) + + case strings.EqualFold("ValidationException", errorCode): + return awsRestjson1_deserializeErrorValidationException(response, errorBody) + + default: + genericError := &smithy.GenericAPIError{ + Code: errorCode, + Message: errorMessage, + } + return genericError + + } +} + +func awsRestjson1_deserializeOpDocumentCancelFlowExecutionsOutput(v **CancelFlowExecutionsOutput, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *CancelFlowExecutionsOutput + if *v == nil { + sv = &CancelFlowExecutionsOutput{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "invalidExecutions": + if err := awsRestjson1_deserializeDocumentExecutionIds(&sv.InvalidExecutions, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + type awsRestjson1_deserializeOpCreateConnectorProfile struct { } @@ -7189,6 +7348,42 @@ func awsRestjson1_deserializeDocumentExecutionDetails(v **types.ExecutionDetails return nil } +func awsRestjson1_deserializeDocumentExecutionIds(v *[]string, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []string + if *v == nil { + cv = []string{} + } else { + cv = *v + } + + for _, value := range shape { + var col string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ExecutionId to be of type string, got %T instead", value) + } + col = jtv + } + cv = append(cv, col) + + } + *v = cv + return nil +} + func awsRestjson1_deserializeDocumentExecutionRecord(v **types.ExecutionRecord, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) diff --git a/service/appflow/generated.json b/service/appflow/generated.json index cb64814d6bc..20f11fd7e56 100644 --- a/service/appflow/generated.json +++ b/service/appflow/generated.json @@ -8,6 +8,7 @@ "files": [ "api_client.go", "api_client_test.go", + "api_op_CancelFlowExecutions.go", "api_op_CreateConnectorProfile.go", "api_op_CreateFlow.go", "api_op_DeleteConnectorProfile.go", diff --git a/service/appflow/serializers.go b/service/appflow/serializers.go index c0fa3709f91..21ec5095d15 100644 --- a/service/appflow/serializers.go +++ b/service/appflow/serializers.go @@ -15,6 +15,81 @@ import ( smithyhttp "github.com/aws/smithy-go/transport/http" ) +type awsRestjson1_serializeOpCancelFlowExecutions struct { +} + +func (*awsRestjson1_serializeOpCancelFlowExecutions) ID() string { + return "OperationSerializer" +} + +func (m *awsRestjson1_serializeOpCancelFlowExecutions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + request, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} + } + + input, ok := in.Parameters.(*CancelFlowExecutionsInput) + _ = input + if !ok { + return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} + } + + opPath, opQuery := httpbinding.SplitURI("/cancel-flow-executions") + request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) + request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) + request.Method = "POST" + restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) + if err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + restEncoder.SetHeader("Content-Type").String("application/json") + + jsonEncoder := smithyjson.NewEncoder() + if err := awsRestjson1_serializeOpDocumentCancelFlowExecutionsInput(input, jsonEncoder.Value); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + + if request.Request, err = restEncoder.Encode(request.Request); err != nil { + return out, metadata, &smithy.SerializationError{Err: err} + } + in.Request = request + + return next.HandleSerialize(ctx, in) +} +func awsRestjson1_serializeOpHttpBindingsCancelFlowExecutionsInput(v *CancelFlowExecutionsInput, encoder *httpbinding.Encoder) error { + if v == nil { + return fmt.Errorf("unsupported serialization of nil %T", v) + } + + return nil +} + +func awsRestjson1_serializeOpDocumentCancelFlowExecutionsInput(v *CancelFlowExecutionsInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.ExecutionIds != nil { + ok := object.Key("executionIds") + if err := awsRestjson1_serializeDocumentExecutionIds(v.ExecutionIds, ok); err != nil { + return err + } + } + + if v.FlowName != nil { + ok := object.Key("flowName") + ok.String(*v.FlowName) + } + + return nil +} + type awsRestjson1_serializeOpCreateConnectorProfile struct { } @@ -2856,6 +2931,17 @@ func awsRestjson1_serializeDocumentEventBridgeDestinationProperties(v *types.Eve return nil } +func awsRestjson1_serializeDocumentExecutionIds(v []string, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + av.String(v[i]) + } + return nil +} + func awsRestjson1_serializeDocumentGlueDataCatalogConfig(v *types.GlueDataCatalogConfig, value smithyjson.Value) error { object := value.Object() defer object.Close() diff --git a/service/appflow/types/enums.go b/service/appflow/types/enums.go index e9f7f5c24fb..75aef97fb36 100644 --- a/service/appflow/types/enums.go +++ b/service/appflow/types/enums.go @@ -280,9 +280,11 @@ type ExecutionStatus string // Enum values for ExecutionStatus const ( - ExecutionStatusInprogress ExecutionStatus = "InProgress" - ExecutionStatusSuccessful ExecutionStatus = "Successful" - ExecutionStatusError ExecutionStatus = "Error" + ExecutionStatusInprogress ExecutionStatus = "InProgress" + ExecutionStatusSuccessful ExecutionStatus = "Successful" + ExecutionStatusError ExecutionStatus = "Error" + ExecutionStatusCancelstarted ExecutionStatus = "CancelStarted" + ExecutionStatusCanceled ExecutionStatus = "Canceled" ) // Values returns all known values for ExecutionStatus. Note that this can be @@ -293,6 +295,8 @@ func (ExecutionStatus) Values() []ExecutionStatus { "InProgress", "Successful", "Error", + "CancelStarted", + "Canceled", } } diff --git a/service/appflow/validators.go b/service/appflow/validators.go index 3b279b24aea..41a37cf6ab6 100644 --- a/service/appflow/validators.go +++ b/service/appflow/validators.go @@ -10,6 +10,26 @@ import ( "github.com/aws/smithy-go/middleware" ) +type validateOpCancelFlowExecutions struct { +} + +func (*validateOpCancelFlowExecutions) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpCancelFlowExecutions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*CancelFlowExecutionsInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpCancelFlowExecutionsInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + type validateOpCreateConnectorProfile struct { } @@ -370,6 +390,10 @@ func (m *validateOpUpdateFlow) HandleInitialize(ctx context.Context, in middlewa return next.HandleInitialize(ctx, in) } +func addOpCancelFlowExecutionsValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpCancelFlowExecutions{}, middleware.After) +} + func addOpCreateConnectorProfileValidationMiddleware(stack *middleware.Stack) error { return stack.Initialize.Add(&validateOpCreateConnectorProfile{}, middleware.After) } @@ -2048,6 +2072,21 @@ func validateZendeskSourceProperties(v *types.ZendeskSourceProperties) error { } } +func validateOpCancelFlowExecutionsInput(v *CancelFlowExecutionsInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "CancelFlowExecutionsInput"} + if v.FlowName == nil { + invalidParams.Add(smithy.NewErrParamRequired("FlowName")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateOpCreateConnectorProfileInput(v *CreateConnectorProfileInput) error { if v == nil { return nil diff --git a/service/connect/types/enums.go b/service/connect/types/enums.go index 61092c7680f..cd9b92018ea 100644 --- a/service/connect/types/enums.go +++ b/service/connect/types/enums.go @@ -461,6 +461,7 @@ const ( EventSourceNameOnZendeskTicketCreate EventSourceName = "OnZendeskTicketCreate" EventSourceNameOnZendeskTicketStatusUpdate EventSourceName = "OnZendeskTicketStatusUpdate" EventSourceNameOnSalesforceCaseCreate EventSourceName = "OnSalesforceCaseCreate" + EventSourceNameOnContactEvaluationSubmit EventSourceName = "OnContactEvaluationSubmit" ) // Values returns all known values for EventSourceName. Note that this can be @@ -474,6 +475,7 @@ func (EventSourceName) Values() []EventSourceName { "OnZendeskTicketCreate", "OnZendeskTicketStatusUpdate", "OnSalesforceCaseCreate", + "OnContactEvaluationSubmit", } } diff --git a/service/ecs/api_op_PutAccountSetting.go b/service/ecs/api_op_PutAccountSetting.go index 130d753d17b..0bee42f03a9 100644 --- a/service/ecs/api_op_PutAccountSetting.go +++ b/service/ecs/api_op_PutAccountSetting.go @@ -77,7 +77,7 @@ type PutAccountSettingInput struct { Name types.SettingName // The account setting value for the specified principal ARN. Accepted values are - // enabled and disabled . + // enabled , disabled , on , and off . // // This member is required. Value *string diff --git a/service/ecs/api_op_PutAccountSettingDefault.go b/service/ecs/api_op_PutAccountSettingDefault.go index f87e9f573b3..0aa4be255c5 100644 --- a/service/ecs/api_op_PutAccountSettingDefault.go +++ b/service/ecs/api_op_PutAccountSettingDefault.go @@ -53,7 +53,7 @@ type PutAccountSettingDefaultInput struct { Name types.SettingName // The account setting value for the specified principal ARN. Accepted values are - // enabled and disabled . + // enabled , disabled , on , and off . // // This member is required. Value *string diff --git a/service/internetmonitor/internal/endpoints/endpoints.go b/service/internetmonitor/internal/endpoints/endpoints.go index 2c9c3281dad..6e2a797b803 100644 --- a/service/internetmonitor/internal/endpoints/endpoints.go +++ b/service/internetmonitor/internal/endpoints/endpoints.go @@ -155,21 +155,11 @@ var defaultPartitions = endpoints.Partitions{ }: endpoints.Endpoint{ Hostname: "internetmonitor.ap-northeast-2.api.aws", }, - endpoints.EndpointKey{ - Region: "ap-northeast-3", - }: endpoints.Endpoint{ - Hostname: "internetmonitor.ap-northeast-3.api.aws", - }, endpoints.EndpointKey{ Region: "ap-south-1", }: endpoints.Endpoint{ Hostname: "internetmonitor.ap-south-1.api.aws", }, - endpoints.EndpointKey{ - Region: "ap-south-2", - }: endpoints.Endpoint{ - Hostname: "internetmonitor.ap-south-2.api.aws", - }, endpoints.EndpointKey{ Region: "ap-southeast-1", }: endpoints.Endpoint{ @@ -180,16 +170,6 @@ var defaultPartitions = endpoints.Partitions{ }: endpoints.Endpoint{ Hostname: "internetmonitor.ap-southeast-2.api.aws", }, - endpoints.EndpointKey{ - Region: "ap-southeast-3", - }: endpoints.Endpoint{ - Hostname: "internetmonitor.ap-southeast-3.api.aws", - }, - endpoints.EndpointKey{ - Region: "ap-southeast-4", - }: endpoints.Endpoint{ - Hostname: "internetmonitor.ap-southeast-4.api.aws", - }, endpoints.EndpointKey{ Region: "ca-central-1", }: endpoints.Endpoint{ @@ -200,11 +180,6 @@ var defaultPartitions = endpoints.Partitions{ }: endpoints.Endpoint{ Hostname: "internetmonitor.eu-central-1.api.aws", }, - endpoints.EndpointKey{ - Region: "eu-central-2", - }: endpoints.Endpoint{ - Hostname: "internetmonitor.eu-central-2.api.aws", - }, endpoints.EndpointKey{ Region: "eu-north-1", }: endpoints.Endpoint{ @@ -215,11 +190,6 @@ var defaultPartitions = endpoints.Partitions{ }: endpoints.Endpoint{ Hostname: "internetmonitor.eu-south-1.api.aws", }, - endpoints.EndpointKey{ - Region: "eu-south-2", - }: endpoints.Endpoint{ - Hostname: "internetmonitor.eu-south-2.api.aws", - }, endpoints.EndpointKey{ Region: "eu-west-1", }: endpoints.Endpoint{ @@ -235,11 +205,6 @@ var defaultPartitions = endpoints.Partitions{ }: endpoints.Endpoint{ Hostname: "internetmonitor.eu-west-3.api.aws", }, - endpoints.EndpointKey{ - Region: "me-central-1", - }: endpoints.Endpoint{ - Hostname: "internetmonitor.me-central-1.api.aws", - }, endpoints.EndpointKey{ Region: "me-south-1", }: endpoints.Endpoint{ diff --git a/service/kendra/api_op_CreateQuerySuggestionsBlockList.go b/service/kendra/api_op_CreateQuerySuggestionsBlockList.go index 1124395bce3..8cac44bb8db 100644 --- a/service/kendra/api_op_CreateQuerySuggestionsBlockList.go +++ b/service/kendra/api_op_CreateQuerySuggestionsBlockList.go @@ -20,7 +20,7 @@ import ( // current quota limits for block lists, see Quotas for Amazon Kendra (https://docs.aws.amazon.com/kendra/latest/dg/quotas.html) // . CreateQuerySuggestionsBlockList is currently not supported in the Amazon Web // Services GovCloud (US-West) region. For an example of creating a block list for -// query suggestions using the Python SDK, see Query suggestions block list (https://docs.aws.amazon.com/kendra/latest/dg/query-suggestions.html#suggestions-block-list) +// query suggestions using the Python SDK, see Query suggestions block list (https://docs.aws.amazon.com/kendra/latest/dg/query-suggestions.html#query-suggestions-blocklist) // . func (c *Client) CreateQuerySuggestionsBlockList(ctx context.Context, params *CreateQuerySuggestionsBlockListInput, optFns ...func(*Options)) (*CreateQuerySuggestionsBlockListOutput, error) { if params == nil { diff --git a/service/kendra/api_op_DescribeQuerySuggestionsConfig.go b/service/kendra/api_op_DescribeQuerySuggestionsConfig.go index 66d4494aa74..675043f927b 100644 --- a/service/kendra/api_op_DescribeQuerySuggestionsConfig.go +++ b/service/kendra/api_op_DescribeQuerySuggestionsConfig.go @@ -44,6 +44,10 @@ type DescribeQuerySuggestionsConfigInput struct { type DescribeQuerySuggestionsConfigOutput struct { + // Configuration information for the document fields/attributes that you want to + // base query suggestions on. + AttributeSuggestionsConfig *types.AttributeSuggestionsDescribeConfig + // TRUE to use all queries, otherwise use only queries that include user // information to generate the query suggestions. IncludeQueriesWithoutUserInformation *bool @@ -54,7 +58,10 @@ type DescribeQuerySuggestionsConfigOutput struct { // considers re-occurences of a query from the time you cleared suggestions. LastClearTime *time.Time - // The Unix timestamp when query suggestions for an index was last updated. + // The Unix timestamp when query suggestions for an index was last updated. Amazon + // Kendra automatically updates suggestions every 24 hours, after you change a + // setting or after you apply a block list (https://docs.aws.amazon.com/kendra/latest/dg/query-suggestions.html#query-suggestions-blocklist) + // . LastSuggestionsBuildTime *time.Time // The minimum number of unique users who must search a query in order for the @@ -83,7 +90,10 @@ type DescribeQuerySuggestionsConfigOutput struct { // The current total count of query suggestions for an index. This count can // change when you update your query suggestions settings, if you filter out // certain queries from suggestions using a block list, and as the query log - // accumulates more queries for Amazon Kendra to learn from. + // accumulates more queries for Amazon Kendra to learn from. If the count is much + // lower than you expected, it could be because Amazon Kendra needs more queries in + // the query history to learn from or your current query suggestions settings are + // too strict. TotalSuggestionsCount *int32 // Metadata pertaining to the operation's result. diff --git a/service/kendra/api_op_GetQuerySuggestions.go b/service/kendra/api_op_GetQuerySuggestions.go index def4b6fbbf7..27ed25b6be0 100644 --- a/service/kendra/api_op_GetQuerySuggestions.go +++ b/service/kendra/api_op_GetQuerySuggestions.go @@ -44,9 +44,22 @@ type GetQuerySuggestionsInput struct { // This member is required. QueryText *string + // Configuration information for the document fields/attributes that you want to + // base query suggestions on. + AttributeSuggestionsConfig *types.AttributeSuggestionsGetConfig + // The maximum number of query suggestions you want to show to your users. MaxSuggestionsCount *int32 + // The suggestions type to base query suggestions on. The suggestion types are + // query history or document fields/attributes. You can set one type or the other. + // If you set query history as your suggestions type, Amazon Kendra suggests + // queries relevant to your users based on popular queries in the query history. If + // you set document fields/attributes as your suggestions type, Amazon Kendra + // suggests queries relevant to your users based on the contents of document + // fields. + SuggestionTypes []types.SuggestionType + noSmithyDocumentSerde } diff --git a/service/kendra/api_op_UpdateFeaturedResultsSet.go b/service/kendra/api_op_UpdateFeaturedResultsSet.go index cfae1a66f7d..2bf9b26a09f 100644 --- a/service/kendra/api_op_UpdateFeaturedResultsSet.go +++ b/service/kendra/api_op_UpdateFeaturedResultsSet.go @@ -32,7 +32,7 @@ func (c *Client) UpdateFeaturedResultsSet(ctx context.Context, params *UpdateFea type UpdateFeaturedResultsSetInput struct { - // The identifier of the index used for featuring results. + // The identifier of the set of featured results that you want to update. // // This member is required. FeaturedResultsSetId *string diff --git a/service/kendra/api_op_UpdateQuerySuggestionsConfig.go b/service/kendra/api_op_UpdateQuerySuggestionsConfig.go index 3f6963b7ecb..fcb45bd3d26 100644 --- a/service/kendra/api_op_UpdateQuerySuggestionsConfig.go +++ b/service/kendra/api_op_UpdateQuerySuggestionsConfig.go @@ -13,11 +13,11 @@ import ( // Updates the settings of query suggestions for an index. Amazon Kendra supports // partial updates, so you only need to provide the fields you want to update. If -// an update is currently processing (i.e. 'happening'), you need to wait for the -// update to finish before making another update. Updates to query suggestions -// settings might not take effect right away. The time for your updated settings to -// take effect depends on the updates made and the number of search queries in your -// index. You can still enable/disable query suggestions at any time. +// an update is currently processing, you need to wait for the update to finish +// before making another update. Updates to query suggestions settings might not +// take effect right away. The time for your updated settings to take effect +// depends on the updates made and the number of search queries in your index. You +// can still enable/disable query suggestions at any time. // UpdateQuerySuggestionsConfig is currently not supported in the Amazon Web // Services GovCloud (US-West) region. func (c *Client) UpdateQuerySuggestionsConfig(ctx context.Context, params *UpdateQuerySuggestionsConfigInput, optFns ...func(*Options)) (*UpdateQuerySuggestionsConfigOutput, error) { @@ -42,6 +42,10 @@ type UpdateQuerySuggestionsConfigInput struct { // This member is required. IndexId *string + // Configuration information for the document fields/attributes that you want to + // base query suggestions on. + AttributeSuggestionsConfig *types.AttributeSuggestionsUpdateConfig + // TRUE to include queries without user information (i.e. all queries, // irrespective of the user), otherwise FALSE to only include queries with user // information. If you pass user information to Amazon Kendra along with the diff --git a/service/kendra/deserializers.go b/service/kendra/deserializers.go index 7b0422bb000..c78d703a079 100644 --- a/service/kendra/deserializers.go +++ b/service/kendra/deserializers.go @@ -8707,6 +8707,51 @@ func awsAwsjson11_deserializeDocumentAssociateEntitiesToExperienceFailedEntityLi return nil } +func awsAwsjson11_deserializeDocumentAttributeSuggestionsDescribeConfig(v **types.AttributeSuggestionsDescribeConfig, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.AttributeSuggestionsDescribeConfig + if *v == nil { + sv = &types.AttributeSuggestionsDescribeConfig{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "AttributeSuggestionsMode": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected AttributeSuggestionsMode to be of type string, got %T instead", value) + } + sv.AttributeSuggestionsMode = types.AttributeSuggestionsMode(jtv) + } + + case "SuggestableConfigList": + if err := awsAwsjson11_deserializeDocumentSuggestableConfigList(&sv.SuggestableConfigList, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeDocumentAuthenticationConfiguration(v **types.AuthenticationConfiguration, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -11461,6 +11506,42 @@ func awsAwsjson11_deserializeDocumentDocumentAttributeCondition(v **types.Docume return nil } +func awsAwsjson11_deserializeDocumentDocumentAttributeKeyList(v *[]string, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []string + if *v == nil { + cv = []string{} + } else { + cv = *v + } + + for _, value := range shape { + var col string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected DocumentAttributeKey to be of type string, got %T instead", value) + } + col = jtv + } + cv = append(cv, col) + + } + *v = cv + return nil +} + func awsAwsjson11_deserializeDocumentDocumentAttributeList(v *[]types.DocumentAttribute, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -18141,6 +18222,90 @@ func awsAwsjson11_deserializeDocumentSnapshotsDataRecords(v *[][]string, value i return nil } +func awsAwsjson11_deserializeDocumentSourceDocument(v **types.SourceDocument, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.SourceDocument + if *v == nil { + sv = &types.SourceDocument{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "AdditionalAttributes": + if err := awsAwsjson11_deserializeDocumentDocumentAttributeList(&sv.AdditionalAttributes, value); err != nil { + return err + } + + case "DocumentId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected String to be of type string, got %T instead", value) + } + sv.DocumentId = ptr.String(jtv) + } + + case "SuggestionAttributes": + if err := awsAwsjson11_deserializeDocumentDocumentAttributeKeyList(&sv.SuggestionAttributes, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentSourceDocuments(v *[]types.SourceDocument, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.SourceDocument + if *v == nil { + cv = []types.SourceDocument{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.SourceDocument + destAddr := &col + if err := awsAwsjson11_deserializeDocumentSourceDocument(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + func awsAwsjson11_deserializeDocumentSpellCorrectedQuery(v **types.SpellCorrectedQuery, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -18399,6 +18564,89 @@ func awsAwsjson11_deserializeDocumentSubnetIdList(v *[]string, value interface{} return nil } +func awsAwsjson11_deserializeDocumentSuggestableConfig(v **types.SuggestableConfig, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.SuggestableConfig + if *v == nil { + sv = &types.SuggestableConfig{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "AttributeName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected DocumentAttributeKey to be of type string, got %T instead", value) + } + sv.AttributeName = ptr.String(jtv) + } + + case "Suggestable": + if value != nil { + jtv, ok := value.(bool) + if !ok { + return fmt.Errorf("expected ObjectBoolean to be of type *bool, got %T instead", value) + } + sv.Suggestable = ptr.Bool(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentSuggestableConfigList(v *[]types.SuggestableConfig, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.([]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var cv []types.SuggestableConfig + if *v == nil { + cv = []types.SuggestableConfig{} + } else { + cv = *v + } + + for _, value := range shape { + var col types.SuggestableConfig + destAddr := &col + if err := awsAwsjson11_deserializeDocumentSuggestableConfig(&destAddr, value); err != nil { + return err + } + col = *destAddr + cv = append(cv, col) + + } + *v = cv + return nil +} + func awsAwsjson11_deserializeDocumentSuggestion(v **types.Suggestion, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -18430,6 +18678,11 @@ func awsAwsjson11_deserializeDocumentSuggestion(v **types.Suggestion, value inte sv.Id = ptr.String(jtv) } + case "SourceDocuments": + if err := awsAwsjson11_deserializeDocumentSourceDocuments(&sv.SourceDocuments, value); err != nil { + return err + } + case "Value": if err := awsAwsjson11_deserializeDocumentSuggestionValue(&sv.Value, value); err != nil { return err @@ -21522,6 +21775,11 @@ func awsAwsjson11_deserializeOpDocumentDescribeQuerySuggestionsConfigOutput(v ** for key, value := range shape { switch key { + case "AttributeSuggestionsConfig": + if err := awsAwsjson11_deserializeDocumentAttributeSuggestionsDescribeConfig(&sv.AttributeSuggestionsConfig, value); err != nil { + return err + } + case "IncludeQueriesWithoutUserInformation": if value != nil { jtv, ok := value.(bool) diff --git a/service/kendra/serializers.go b/service/kendra/serializers.go index ed1b3bb8b44..aa53f10dd88 100644 --- a/service/kendra/serializers.go +++ b/service/kendra/serializers.go @@ -3808,6 +3808,60 @@ func awsAwsjson11_serializeDocumentAttributeFilterList(v []types.AttributeFilter return nil } +func awsAwsjson11_serializeDocumentAttributeSuggestionsGetConfig(v *types.AttributeSuggestionsGetConfig, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.AdditionalResponseAttributes != nil { + ok := object.Key("AdditionalResponseAttributes") + if err := awsAwsjson11_serializeDocumentDocumentAttributeKeyList(v.AdditionalResponseAttributes, ok); err != nil { + return err + } + } + + if v.AttributeFilter != nil { + ok := object.Key("AttributeFilter") + if err := awsAwsjson11_serializeDocumentAttributeFilter(v.AttributeFilter, ok); err != nil { + return err + } + } + + if v.SuggestionAttributes != nil { + ok := object.Key("SuggestionAttributes") + if err := awsAwsjson11_serializeDocumentDocumentAttributeKeyList(v.SuggestionAttributes, ok); err != nil { + return err + } + } + + if v.UserContext != nil { + ok := object.Key("UserContext") + if err := awsAwsjson11_serializeDocumentUserContext(v.UserContext, ok); err != nil { + return err + } + } + + return nil +} + +func awsAwsjson11_serializeDocumentAttributeSuggestionsUpdateConfig(v *types.AttributeSuggestionsUpdateConfig, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if len(v.AttributeSuggestionsMode) > 0 { + ok := object.Key("AttributeSuggestionsMode") + ok.String(string(v.AttributeSuggestionsMode)) + } + + if v.SuggestableConfigList != nil { + ok := object.Key("SuggestableConfigList") + if err := awsAwsjson11_serializeDocumentSuggestableConfigList(v.SuggestableConfigList, ok); err != nil { + return err + } + } + + return nil +} + func awsAwsjson11_serializeDocumentAuthenticationConfiguration(v *types.AuthenticationConfiguration, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -7226,6 +7280,47 @@ func awsAwsjson11_serializeDocumentSubnetIdList(v []string, value smithyjson.Val return nil } +func awsAwsjson11_serializeDocumentSuggestableConfig(v *types.SuggestableConfig, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.AttributeName != nil { + ok := object.Key("AttributeName") + ok.String(*v.AttributeName) + } + + if v.Suggestable != nil { + ok := object.Key("Suggestable") + ok.Boolean(*v.Suggestable) + } + + return nil +} + +func awsAwsjson11_serializeDocumentSuggestableConfigList(v []types.SuggestableConfig, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + if err := awsAwsjson11_serializeDocumentSuggestableConfig(&v[i], av); err != nil { + return err + } + } + return nil +} + +func awsAwsjson11_serializeDocumentSuggestionTypes(v []types.SuggestionType, value smithyjson.Value) error { + array := value.Array() + defer array.Close() + + for i := range v { + av := array.Value() + av.String(string(v[i])) + } + return nil +} + func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -8486,6 +8581,13 @@ func awsAwsjson11_serializeOpDocumentGetQuerySuggestionsInput(v *GetQuerySuggest object := value.Object() defer object.Close() + if v.AttributeSuggestionsConfig != nil { + ok := object.Key("AttributeSuggestionsConfig") + if err := awsAwsjson11_serializeDocumentAttributeSuggestionsGetConfig(v.AttributeSuggestionsConfig, ok); err != nil { + return err + } + } + if v.IndexId != nil { ok := object.Key("IndexId") ok.String(*v.IndexId) @@ -8501,6 +8603,13 @@ func awsAwsjson11_serializeOpDocumentGetQuerySuggestionsInput(v *GetQuerySuggest ok.String(*v.QueryText) } + if v.SuggestionTypes != nil { + ok := object.Key("SuggestionTypes") + if err := awsAwsjson11_serializeDocumentSuggestionTypes(v.SuggestionTypes, ok); err != nil { + return err + } + } + return nil } @@ -9359,6 +9468,13 @@ func awsAwsjson11_serializeOpDocumentUpdateQuerySuggestionsConfigInput(v *Update object := value.Object() defer object.Close() + if v.AttributeSuggestionsConfig != nil { + ok := object.Key("AttributeSuggestionsConfig") + if err := awsAwsjson11_serializeDocumentAttributeSuggestionsUpdateConfig(v.AttributeSuggestionsConfig, ok); err != nil { + return err + } + } + if v.IncludeQueriesWithoutUserInformation != nil { ok := object.Key("IncludeQueriesWithoutUserInformation") ok.Boolean(*v.IncludeQueriesWithoutUserInformation) diff --git a/service/kendra/types/enums.go b/service/kendra/types/enums.go index c5a3ade56bd..803208539c9 100644 --- a/service/kendra/types/enums.go +++ b/service/kendra/types/enums.go @@ -39,6 +39,24 @@ func (AlfrescoEntity) Values() []AlfrescoEntity { } } +type AttributeSuggestionsMode string + +// Enum values for AttributeSuggestionsMode +const ( + AttributeSuggestionsModeActive AttributeSuggestionsMode = "ACTIVE" + AttributeSuggestionsModeInactive AttributeSuggestionsMode = "INACTIVE" +) + +// Values returns all known values for AttributeSuggestionsMode. Note that this +// can be expanded in the future, and so it is only as up to date as the client. +// The ordering of this slice is not guaranteed to be stable across updates. +func (AttributeSuggestionsMode) Values() []AttributeSuggestionsMode { + return []AttributeSuggestionsMode{ + "ACTIVE", + "INACTIVE", + } +} + type ConditionOperator string // Enum values for ConditionOperator @@ -1222,6 +1240,24 @@ func (SortOrder) Values() []SortOrder { } } +type SuggestionType string + +// Enum values for SuggestionType +const ( + SuggestionTypeQuery SuggestionType = "QUERY" + SuggestionTypeDocumentAttributes SuggestionType = "DOCUMENT_ATTRIBUTES" +) + +// Values returns all known values for SuggestionType. Note that this can be +// expanded in the future, and so it is only as up to date as the client. The +// ordering of this slice is not guaranteed to be stable across updates. +func (SuggestionType) Values() []SuggestionType { + return []SuggestionType{ + "QUERY", + "DOCUMENT_ATTRIBUTES", + } +} + type ThesaurusStatus string // Enum values for ThesaurusStatus diff --git a/service/kendra/types/types.go b/service/kendra/types/types.go index 9c6567b836d..e2d0f681c9b 100644 --- a/service/kendra/types/types.go +++ b/service/kendra/types/types.go @@ -216,6 +216,76 @@ type AttributeFilter struct { noSmithyDocumentSerde } +// Gets information on the configuration of document fields/attributes that you +// want to base query suggestions on. To change your configuration, use +// AttributeSuggestionsUpdateConfig (https://docs.aws.amazon.com/kendra/latest/dg/API_AttributeSuggestionsUpdateConfig.html) +// and then call UpdateQuerySuggestionsConfig (https://docs.aws.amazon.com/kendra/latest/dg/API_UpdateQuerySuggestionsConfig.html) +// . +type AttributeSuggestionsDescribeConfig struct { + + // The mode is set to either ACTIVE or INACTIVE . If the Mode for query history is + // set to ENABLED when calling UpdateQuerySuggestionsConfig (https://docs.aws.amazon.com/kendra/latest/dg/API_UpdateQuerySuggestionsConfig.html) + // and AttributeSuggestionsMode to use fields/attributes is set to ACTIVE , and you + // haven't set your SuggestionTypes preference to DOCUMENT_ATTRIBUTES , then Amazon + // Kendra uses the query history. + AttributeSuggestionsMode AttributeSuggestionsMode + + // The list of fields/attributes that you want to set as suggestible for query + // suggestions. + SuggestableConfigList []SuggestableConfig + + noSmithyDocumentSerde +} + +// Provides the configuration information for the document fields/attributes that +// you want to base query suggestions on. +type AttributeSuggestionsGetConfig struct { + + // The list of additional document field/attribute keys or field names to include + // in the response. You can use additional fields to provide extra information in + // the response. Additional fields are not used to based suggestions on. + AdditionalResponseAttributes []string + + // Filters the search results based on document fields/attributes. + AttributeFilter *AttributeFilter + + // The list of document field/attribute keys or field names to use for query + // suggestions. If the content within any of the fields match what your user starts + // typing as their query, then the field content is returned as a query suggestion. + SuggestionAttributes []string + + // Applies user context filtering so that only users who are given access to + // certain documents see these document in their search results. + UserContext *UserContext + + noSmithyDocumentSerde +} + +// Updates the configuration information for the document fields/attributes that +// you want to base query suggestions on. To deactivate using documents fields for +// query suggestions, set the mode to INACTIVE . You must also set SuggestionTypes +// as either QUERY or DOCUMENT_ATTRIBUTES and then call GetQuerySuggestions (https://docs.aws.amazon.com/kendra/latest/dg/API_GetQuerySuggestions.html) +// . If you set to QUERY , then Amazon Kendra uses the query history to base +// suggestions on. If you set to DOCUMENT_ATTRIBUTES , then Amazon Kendra uses the +// contents of document fields to base suggestions on. +type AttributeSuggestionsUpdateConfig struct { + + // You can set the mode to ACTIVE or INACTIVE . You must also set SuggestionTypes + // as either QUERY or DOCUMENT_ATTRIBUTES and then call GetQuerySuggestions (https://docs.aws.amazon.com/kendra/latest/dg/API_GetQuerySuggestions.html) + // . If Mode to use query history is set to ENABLED when calling + // UpdateQuerySuggestionsConfig (https://docs.aws.amazon.com/kendra/latest/dg/API_UpdateQuerySuggestionsConfig.html) + // and AttributeSuggestionsMode to use fields/attributes is set to ACTIVE , and you + // haven't set your SuggestionTypes preference to DOCUMENT_ATTRIBUTES , then Amazon + // Kendra uses the query history. + AttributeSuggestionsMode AttributeSuggestionsMode + + // The list of fields/attributes that you want to set as suggestible for query + // suggestions. + SuggestableConfigList []SuggestableConfig + + noSmithyDocumentSerde +} + // Provides the configuration information to connect to websites that require user // authentication. type AuthenticationConfiguration struct { @@ -3659,6 +3729,24 @@ type SortingConfiguration struct { noSmithyDocumentSerde } +// The document ID and its fields/attributes that are used for a query suggestion, +// if document fields set to use for query suggestions. +type SourceDocument struct { + + // The additional fields/attributes to include in the response. You can use + // additional fields to provide extra information in the response. Additional + // fields are not used to based suggestions on. + AdditionalAttributes []DocumentAttribute + + // The identifier of the document used for a query suggestion. + DocumentId *string + + // The document fields/attributes used for a query suggestion. + SuggestionAttributes []string + + noSmithyDocumentSerde +} + // A query with suggested spell corrections. type SpellCorrectedQuery struct { @@ -3726,12 +3814,30 @@ type Status struct { noSmithyDocumentSerde } +// Provides the configuration information for a document field/attribute that you +// want to base query suggestions on. +type SuggestableConfig struct { + + // The name of the document field/attribute. + AttributeName *string + + // TRUE means the document field/attribute is suggestible, so the contents within + // the field can be used for query suggestions. + Suggestable *bool + + noSmithyDocumentSerde +} + // A single query suggestion. type Suggestion struct { // The UUID (universally unique identifier) of a single query suggestion. Id *string + // The list of document IDs and their fields/attributes that are used for a single + // query suggestion, if document fields set to use for query suggestions. + SourceDocuments []SourceDocument + // The value for the UUID (universally unique identifier) of a single query // suggestion. The value is the text string of a suggestion. Value *SuggestionValue diff --git a/service/kendra/validators.go b/service/kendra/validators.go index 6fbd9b4e8b8..6997f95b9d8 100644 --- a/service/kendra/validators.go +++ b/service/kendra/validators.go @@ -1705,6 +1705,28 @@ func validateAttributeFilterList(v []types.AttributeFilter) error { } } +func validateAttributeSuggestionsGetConfig(v *types.AttributeSuggestionsGetConfig) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "AttributeSuggestionsGetConfig"} + if v.AttributeFilter != nil { + if err := validateAttributeFilter(v.AttributeFilter); err != nil { + invalidParams.AddNested("AttributeFilter", err.(smithy.InvalidParamsError)) + } + } + if v.UserContext != nil { + if err := validateUserContext(v.UserContext); err != nil { + invalidParams.AddNested("UserContext", err.(smithy.InvalidParamsError)) + } + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + func validateAuthenticationConfiguration(v *types.AuthenticationConfiguration) error { if v == nil { return nil @@ -4477,6 +4499,11 @@ func validateOpGetQuerySuggestionsInput(v *GetQuerySuggestionsInput) error { if v.QueryText == nil { invalidParams.Add(smithy.NewErrParamRequired("QueryText")) } + if v.AttributeSuggestionsConfig != nil { + if err := validateAttributeSuggestionsGetConfig(v.AttributeSuggestionsConfig); err != nil { + invalidParams.AddNested("AttributeSuggestionsConfig", err.(smithy.InvalidParamsError)) + } + } if invalidParams.Len() > 0 { return invalidParams } else { diff --git a/service/resiliencehub/api_op_CreateApp.go b/service/resiliencehub/api_op_CreateApp.go index 33bfbd60d93..ae1f2cfe291 100644 --- a/service/resiliencehub/api_op_CreateApp.go +++ b/service/resiliencehub/api_op_CreateApp.go @@ -14,14 +14,16 @@ import ( // Creates an Resilience Hub application. An Resilience Hub application is a // collection of Amazon Web Services resources structured to prevent and recover -// Amazon Web Services application disruptions. To describe a Resilience Hub -// application, you provide an application name, resources from one or more–up to -// 20–CloudFormation stacks, and an appropriate resiliency policy. After you create -// an Resilience Hub application, you publish it so that you can run a resiliency -// assessment on it. You can then use recommendations from the assessment to -// improve resiliency by running another assessment, comparing results, and then -// iterating the process until you achieve your goals for recovery time objective -// (RTO) and recovery point objective (RPO). +// Amazon Web Services application disruptions. To describe an Resilience Hub +// application, you provide an application name, resources from one or more +// CloudFormation stacks, Resource Groups, Terraform state files, AppRegistry +// applications, and an appropriate resiliency policy. For more information about +// the number of resources supported per application, see Service Quotas (https://docs.aws.amazon.com/general/latest/gr/resiliencehub.html#limits_resiliencehub) +// . After you create an Resilience Hub application, you publish it so that you can +// run a resiliency assessment on it. You can then use recommendations from the +// assessment to improve resiliency by running another assessment, comparing +// results, and then iterating the process until you achieve your goals for +// recovery time objective (RTO) and recovery point objective (RPO). func (c *Client) CreateApp(ctx context.Context, params *CreateAppInput, optFns ...func(*Options)) (*CreateAppOutput, error) { if params == nil { params = &CreateAppInput{} diff --git a/service/resiliencehub/api_op_CreateAppVersionResource.go b/service/resiliencehub/api_op_CreateAppVersionResource.go index 68d371b75cc..bb5330a6647 100644 --- a/service/resiliencehub/api_op_CreateAppVersionResource.go +++ b/service/resiliencehub/api_op_CreateAppVersionResource.go @@ -63,11 +63,6 @@ type CreateAppVersionResourceInput struct { // This member is required. PhysicalResourceId *string - // The name of the resource. - // - // This member is required. - ResourceName *string - // The type of resource. // // This member is required. @@ -87,6 +82,9 @@ type CreateAppVersionResourceInput struct { // for other API requests. ClientToken *string + // The name of the resource. + ResourceName *string + noSmithyDocumentSerde } diff --git a/service/resiliencehub/deserializers.go b/service/resiliencehub/deserializers.go index f863e8d5ca0..5b48ba2551c 100644 --- a/service/resiliencehub/deserializers.go +++ b/service/resiliencehub/deserializers.go @@ -11595,6 +11595,15 @@ func awsRestjson1_deserializeDocumentPhysicalResource(v **types.PhysicalResource return err } + case "parentResourceName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected EntityName to be of type string, got %T instead", value) + } + sv.ParentResourceName = ptr.String(jtv) + } + case "physicalResourceId": if err := awsRestjson1_deserializeDocumentPhysicalResourceId(&sv.PhysicalResourceId, value); err != nil { return err @@ -11618,6 +11627,15 @@ func awsRestjson1_deserializeDocumentPhysicalResource(v **types.PhysicalResource sv.ResourceType = ptr.String(jtv) } + case "sourceType": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ResourceSourceType to be of type string, got %T instead", value) + } + sv.SourceType = types.ResourceSourceType(jtv) + } + default: _, _ = key, value diff --git a/service/resiliencehub/types/enums.go b/service/resiliencehub/types/enums.go index 959ad1bd8ad..10b7a2eb66d 100644 --- a/service/resiliencehub/types/enums.go +++ b/service/resiliencehub/types/enums.go @@ -474,6 +474,24 @@ func (ResourceResolutionStatusType) Values() []ResourceResolutionStatusType { } } +type ResourceSourceType string + +// Enum values for ResourceSourceType +const ( + ResourceSourceTypeAppTemplate ResourceSourceType = "AppTemplate" + ResourceSourceTypeDiscovered ResourceSourceType = "Discovered" +) + +// Values returns all known values for ResourceSourceType. Note that this can be +// expanded in the future, and so it is only as up to date as the client. The +// ordering of this slice is not guaranteed to be stable across updates. +func (ResourceSourceType) Values() []ResourceSourceType { + return []ResourceSourceType{ + "AppTemplate", + "Discovered", + } +} + type SopServiceType string // Enum values for SopServiceType diff --git a/service/resiliencehub/types/types.go b/service/resiliencehub/types/types.go index fcfca234368..949fd21bfb6 100644 --- a/service/resiliencehub/types/types.go +++ b/service/resiliencehub/types/types.go @@ -594,9 +594,15 @@ type PhysicalResource struct { // Indicates if a resource is included or excluded from the assessment. Excluded *bool + // The name of the parent resource. + ParentResourceName *string + // The name of the resource. ResourceName *string + // The type of input source. + SourceType ResourceSourceType + noSmithyDocumentSerde } diff --git a/service/resiliencehub/validators.go b/service/resiliencehub/validators.go index 04356b8dff8..a950b222483 100644 --- a/service/resiliencehub/validators.go +++ b/service/resiliencehub/validators.go @@ -1415,9 +1415,6 @@ func validateOpCreateAppVersionResourceInput(v *CreateAppVersionResourceInput) e if v.AppArn == nil { invalidParams.Add(smithy.NewErrParamRequired("AppArn")) } - if v.ResourceName == nil { - invalidParams.Add(smithy.NewErrParamRequired("ResourceName")) - } if v.LogicalResourceId == nil { invalidParams.Add(smithy.NewErrParamRequired("LogicalResourceId")) } else if v.LogicalResourceId != nil { diff --git a/service/sagemaker/deserializers.go b/service/sagemaker/deserializers.go index a4080d1df23..5a5297f9d25 100644 --- a/service/sagemaker/deserializers.go +++ b/service/sagemaker/deserializers.go @@ -35020,6 +35020,15 @@ func awsAwsjson11_deserializeDocumentAutoMLChannel(v **types.AutoMLChannel, valu return err } + case "SampleWeightAttributeName": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected SampleWeightAttributeName to be of type string, got %T instead", value) + } + sv.SampleWeightAttributeName = ptr.String(jtv) + } + case "TargetAttributeName": if value != nil { jtv, ok := value.(string) diff --git a/service/sagemaker/serializers.go b/service/sagemaker/serializers.go index 87d558b1e25..f9558450123 100644 --- a/service/sagemaker/serializers.go +++ b/service/sagemaker/serializers.go @@ -17187,6 +17187,11 @@ func awsAwsjson11_serializeDocumentAutoMLChannel(v *types.AutoMLChannel, value s } } + if v.SampleWeightAttributeName != nil { + ok := object.Key("SampleWeightAttributeName") + ok.String(*v.SampleWeightAttributeName) + } + if v.TargetAttributeName != nil { ok := object.Key("TargetAttributeName") ok.String(*v.TargetAttributeName) diff --git a/service/sagemaker/types/types.go b/service/sagemaker/types/types.go index c86a488a59e..0d3d84d828d 100644 --- a/service/sagemaker/types/types.go +++ b/service/sagemaker/types/types.go @@ -1257,6 +1257,17 @@ type AutoMLChannel struct { // is text/csv;header=present . ContentType *string + // If specified, this column name indicates which column of the dataset should be + // treated as sample weights for use by the objective metric during the training, + // evaluation, and the selection of the best model. This column is not considered + // as a predictive feature. For more information on Autopilot metrics, see Metrics + // and validation (https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-metrics-validation.html) + // . Sample weights should be numeric, non-negative, with larger values indicating + // which rows are more important than others. Data points that have invalid or no + // weight value are excluded. Support for sample weights is available in Ensembling (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLAlgorithmConfig.html) + // mode only. + SampleWeightAttributeName *string + noSmithyDocumentSerde } @@ -1428,103 +1439,11 @@ type AutoMLJobConfig struct { type AutoMLJobObjective struct { // The name of the objective metric used to measure the predictive quality of a - // machine learning system. This metric is optimized during training to provide the - // best estimate for model parameter values from data. Here are the options: - // Accuracy The ratio of the number of correctly classified items to the total - // number of (correctly and incorrectly) classified items. It is used for both - // binary and multiclass classification. Accuracy measures how close the predicted - // class values are to the actual values. Values for accuracy metrics vary between - // zero (0) and one (1). A value of 1 indicates perfect accuracy, and 0 indicates - // perfect inaccuracy. AUC The area under the curve (AUC) metric is used to compare - // and evaluate binary classification by algorithms that return probabilities, such - // as logistic regression. To map the probabilities into classifications, these are - // compared against a threshold value. The relevant curve is the receiver operating - // characteristic curve (ROC curve). The ROC curve plots the true positive rate - // (TPR) of predictions (or recall) against the false positive rate (FPR) as a - // function of the threshold value, above which a prediction is considered - // positive. Increasing the threshold results in fewer false positives, but more - // false negatives. AUC is the area under this ROC curve. Therefore, AUC provides - // an aggregated measure of the model performance across all possible - // classification thresholds. AUC scores vary between 0 and 1. A score of 1 - // indicates perfect accuracy, and a score of one half (0.5) indicates that the - // prediction is not better than a random classifier. BalancedAccuracy - // BalancedAccuracy is a metric that measures the ratio of accurate predictions to - // all predictions. This ratio is calculated after normalizing true positives (TP) - // and true negatives (TN) by the total number of positive (P) and negative (N) - // values. It is used in both binary and multiclass classification and is defined - // as follows: 0.5*((TP/P)+(TN/N)), with values ranging from 0 to 1. - // BalancedAccuracy gives a better measure of accuracy when the number of positives - // or negatives differ greatly from each other in an imbalanced dataset. For - // example, when only 1% of email is spam. F1 The F1 score is the harmonic mean of - // the precision and recall, defined as follows: F1 = 2 * (precision * recall) / - // (precision + recall). It is used for binary classification into classes - // traditionally referred to as positive and negative. Predictions are said to be - // true when they match their actual (correct) class, and false when they do not. - // Precision is the ratio of the true positive predictions to all positive - // predictions, and it includes the false positives in a dataset. Precision - // measures the quality of the prediction when it predicts the positive class. - // Recall (or sensitivity) is the ratio of the true positive predictions to all - // actual positive instances. Recall measures how completely a model predicts the - // actual class members in a dataset. F1 scores vary between 0 and 1. A score of 1 - // indicates the best possible performance, and 0 indicates the worst. F1macro The - // F1macro score applies F1 scoring to multiclass classification problems. It does - // this by calculating the precision and recall, and then taking their harmonic - // mean to calculate the F1 score for each class. Lastly, the F1macro averages the - // individual scores to obtain the F1macro score. F1macro scores vary between 0 - // and 1. A score of 1 indicates the best possible performance, and 0 indicates the - // worst. MAE The mean absolute error (MAE) is a measure of how different the - // predicted and actual values are, when they're averaged over all values. MAE is - // commonly used in regression analysis to understand model prediction error. If - // there is linear regression, MAE represents the average distance from a predicted - // line to the actual value. MAE is defined as the sum of absolute errors divided - // by the number of observations. Values range from 0 to infinity, with smaller - // numbers indicating a better model fit to the data. MSE The mean squared error - // (MSE) is the average of the squared differences between the predicted and actual - // values. It is used for regression. MSE values are always positive. The better a - // model is at predicting the actual values, the smaller the MSE value is Precision - // Precision measures how well an algorithm predicts the true positives (TP) out of - // all of the positives that it identifies. It is defined as follows: Precision = - // TP/(TP+FP), with values ranging from zero (0) to one (1), and is used in binary - // classification. Precision is an important metric when the cost of a false - // positive is high. For example, the cost of a false positive is very high if an - // airplane safety system is falsely deemed safe to fly. A false positive (FP) - // reflects a positive prediction that is actually negative in the data. - // PrecisionMacro The precision macro computes precision for multiclass - // classification problems. It does this by calculating precision for each class - // and averaging scores to obtain precision for several classes. PrecisionMacro - // scores range from zero (0) to one (1). Higher scores reflect the model's ability - // to predict true positives (TP) out of all of the positives that it identifies, - // averaged across multiple classes. R2 R2, also known as the coefficient of - // determination, is used in regression to quantify how much a model can explain - // the variance of a dependent variable. Values range from one (1) to negative one - // (-1). Higher numbers indicate a higher fraction of explained variability. R2 - // values close to zero (0) indicate that very little of the dependent variable can - // be explained by the model. Negative values indicate a poor fit and that the - // model is outperformed by a constant function. For linear regression, this is a - // horizontal line. Recall Recall measures how well an algorithm correctly predicts - // all of the true positives (TP) in a dataset. A true positive is a positive - // prediction that is also an actual positive value in the data. Recall is defined - // as follows: Recall = TP/(TP+FN), with values ranging from 0 to 1. Higher scores - // reflect a better ability of the model to predict true positives (TP) in the - // data, and is used in binary classification. Recall is important when testing for - // cancer because it's used to find all of the true positives. A false positive - // (FP) reflects a positive prediction that is actually negative in the data. It is - // often insufficient to measure only recall, because predicting every output as a - // true positive yield a perfect recall score. RecallMacro The RecallMacro computes - // recall for multiclass classification problems by calculating recall for each - // class and averaging scores to obtain recall for several classes. RecallMacro - // scores range from 0 to 1. Higher scores reflect the model's ability to predict - // true positives (TP) in a dataset. Whereas, a true positive reflects a positive - // prediction that is also an actual positive value in the data. It is often - // insufficient to measure only recall, because predicting every output as a true - // positive yields a perfect recall score. RMSE Root mean squared error (RMSE) - // measures the square root of the squared difference between predicted and actual - // values, and it's averaged over all values. It is used in regression analysis to - // understand model prediction error. It's an important metric to indicate the - // presence of large model errors and outliers. Values range from zero (0) to - // infinity, with smaller numbers indicating a better model fit to the data. RMSE - // is dependent on scale, and should not be used to compare datasets of different - // sizes. If you do not specify a metric explicitly, the default behavior is to + // machine learning system. During training, the model's parameters are updated + // iteratively to optimize its performance based on the feedback provided by the + // objective metric when evaluating the model on the validation dataset. For the + // list of all available metrics supported by Autopilot, see Autopilot metrics (https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-metrics-validation.html#autopilot-metrics) + // . If you do not specify a metric explicitly, the default behavior is to // automatically use: // - MSE : for regression. // - F1 : for binary classification diff --git a/service/signer/internal/endpoints/endpoints.go b/service/signer/internal/endpoints/endpoints.go index 680667c4f14..3cbde5e89d9 100644 --- a/service/signer/internal/endpoints/endpoints.go +++ b/service/signer/internal/endpoints/endpoints.go @@ -134,6 +134,128 @@ var defaultPartitions = endpoints.Partitions{ }, RegionRegex: partitionRegexp.Aws, IsRegionalized: true, + Endpoints: endpoints.Endpoints{ + endpoints.EndpointKey{ + Region: "af-south-1", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-east-1", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-northeast-1", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-northeast-2", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-south-1", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-southeast-1", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-southeast-2", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ca-central-1", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-central-1", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-north-1", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-south-1", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-west-1", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-west-2", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-west-3", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "fips-us-east-1", + }: endpoints.Endpoint{ + Hostname: "signer-fips.us-east-1.amazonaws.com", + CredentialScope: endpoints.CredentialScope{ + Region: "us-east-1", + }, + Deprecated: aws.TrueTernary, + }, + endpoints.EndpointKey{ + Region: "fips-us-east-2", + }: endpoints.Endpoint{ + Hostname: "signer-fips.us-east-2.amazonaws.com", + CredentialScope: endpoints.CredentialScope{ + Region: "us-east-2", + }, + Deprecated: aws.TrueTernary, + }, + endpoints.EndpointKey{ + Region: "fips-us-west-1", + }: endpoints.Endpoint{ + Hostname: "signer-fips.us-west-1.amazonaws.com", + CredentialScope: endpoints.CredentialScope{ + Region: "us-west-1", + }, + Deprecated: aws.TrueTernary, + }, + endpoints.EndpointKey{ + Region: "fips-us-west-2", + }: endpoints.Endpoint{ + Hostname: "signer-fips.us-west-2.amazonaws.com", + CredentialScope: endpoints.CredentialScope{ + Region: "us-west-2", + }, + Deprecated: aws.TrueTernary, + }, + endpoints.EndpointKey{ + Region: "me-south-1", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "sa-east-1", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "us-east-1", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "us-east-1", + Variant: endpoints.FIPSVariant, + }: { + Hostname: "signer-fips.us-east-1.amazonaws.com", + }, + endpoints.EndpointKey{ + Region: "us-east-2", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "us-east-2", + Variant: endpoints.FIPSVariant, + }: { + Hostname: "signer-fips.us-east-2.amazonaws.com", + }, + endpoints.EndpointKey{ + Region: "us-west-1", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "us-west-1", + Variant: endpoints.FIPSVariant, + }: { + Hostname: "signer-fips.us-west-1.amazonaws.com", + }, + endpoints.EndpointKey{ + Region: "us-west-2", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "us-west-2", + Variant: endpoints.FIPSVariant, + }: { + Hostname: "signer-fips.us-west-2.amazonaws.com", + }, + }, }, { ID: "aws-cn", @@ -169,6 +291,14 @@ var defaultPartitions = endpoints.Partitions{ }, RegionRegex: partitionRegexp.AwsCn, IsRegionalized: true, + Endpoints: endpoints.Endpoints{ + endpoints.EndpointKey{ + Region: "cn-north-1", + }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "cn-northwest-1", + }: endpoints.Endpoint{}, + }, }, { ID: "aws-iso",