repo_name
stringlengths 1
52
| repo_creator
stringclasses 6
values | programming_language
stringclasses 4
values | code
stringlengths 0
9.68M
| num_lines
int64 1
234k
|
|---|---|---|---|---|
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakeredge
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/aws-sdk-go-v2/service/sagemakeredge/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Use to get the active deployments from a device.
func (c *Client) GetDeployments(ctx context.Context, params *GetDeploymentsInput, optFns ...func(*Options)) (*GetDeploymentsOutput, error) {
if params == nil {
params = &GetDeploymentsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetDeployments", params, optFns, c.addOperationGetDeploymentsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetDeploymentsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetDeploymentsInput struct {
// The name of the fleet that the device belongs to.
//
// This member is required.
DeviceFleetName *string
// The unique name of the device you want to get the configuration of active
// deployments from.
//
// This member is required.
DeviceName *string
noSmithyDocumentSerde
}
type GetDeploymentsOutput struct {
// Returns a list of the configurations of the active deployments on the device.
Deployments []types.EdgeDeployment
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetDeploymentsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetDeployments{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetDeployments{}, 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 = addOpGetDeploymentsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetDeployments(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_opGetDeployments(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "GetDeployments",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakeredge
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"
)
// Use to check if a device is registered with SageMaker Edge Manager.
func (c *Client) GetDeviceRegistration(ctx context.Context, params *GetDeviceRegistrationInput, optFns ...func(*Options)) (*GetDeviceRegistrationOutput, error) {
if params == nil {
params = &GetDeviceRegistrationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetDeviceRegistration", params, optFns, c.addOperationGetDeviceRegistrationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetDeviceRegistrationOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetDeviceRegistrationInput struct {
// The name of the fleet that the device belongs to.
//
// This member is required.
DeviceFleetName *string
// The unique name of the device you want to get the registration status from.
//
// This member is required.
DeviceName *string
noSmithyDocumentSerde
}
type GetDeviceRegistrationOutput struct {
// The amount of time, in seconds, that the registration status is stored on the
// device’s cache before it is refreshed.
CacheTTL *string
// Describes if the device is currently registered with SageMaker Edge Manager.
DeviceRegistration *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetDeviceRegistrationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetDeviceRegistration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetDeviceRegistration{}, 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 = addOpGetDeviceRegistrationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetDeviceRegistration(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_opGetDeviceRegistration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "GetDeviceRegistration",
}
}
| 133 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakeredge
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/aws-sdk-go-v2/service/sagemakeredge/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Use to get the current status of devices registered on SageMaker Edge Manager.
func (c *Client) SendHeartbeat(ctx context.Context, params *SendHeartbeatInput, optFns ...func(*Options)) (*SendHeartbeatOutput, error) {
if params == nil {
params = &SendHeartbeatInput{}
}
result, metadata, err := c.invokeOperation(ctx, "SendHeartbeat", params, optFns, c.addOperationSendHeartbeatMiddlewares)
if err != nil {
return nil, err
}
out := result.(*SendHeartbeatOutput)
out.ResultMetadata = metadata
return out, nil
}
type SendHeartbeatInput struct {
// Returns the version of the agent.
//
// This member is required.
AgentVersion *string
// The name of the fleet that the device belongs to.
//
// This member is required.
DeviceFleetName *string
// The unique name of the device.
//
// This member is required.
DeviceName *string
// For internal use. Returns a list of SageMaker Edge Manager agent operating
// metrics.
AgentMetrics []types.EdgeMetric
// Returns the result of a deployment on the device.
DeploymentResult *types.DeploymentResult
// Returns a list of models deployed on the the device.
Models []types.Model
noSmithyDocumentSerde
}
type SendHeartbeatOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationSendHeartbeatMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpSendHeartbeat{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpSendHeartbeat{}, 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 = addOpSendHeartbeatValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opSendHeartbeat(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_opSendHeartbeat(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "SendHeartbeat",
}
}
| 141 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakeredge
import (
"bytes"
"context"
"encoding/json"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
"github.com/aws/aws-sdk-go-v2/service/sagemakeredge/types"
smithy "github.com/aws/smithy-go"
smithyio "github.com/aws/smithy-go/io"
"github.com/aws/smithy-go/middleware"
"github.com/aws/smithy-go/ptr"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io"
"io/ioutil"
"strings"
)
type awsRestjson1_deserializeOpGetDeployments struct {
}
func (*awsRestjson1_deserializeOpGetDeployments) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetDeployments) 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_deserializeOpErrorGetDeployments(response, &metadata)
}
output := &GetDeploymentsOutput{}
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_deserializeOpDocumentGetDeploymentsOutput(&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_deserializeOpErrorGetDeployments(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("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetDeploymentsOutput(v **GetDeploymentsOutput, 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 *GetDeploymentsOutput
if *v == nil {
sv = &GetDeploymentsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Deployments":
if err := awsRestjson1_deserializeDocumentEdgeDeployments(&sv.Deployments, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetDeviceRegistration struct {
}
func (*awsRestjson1_deserializeOpGetDeviceRegistration) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetDeviceRegistration) 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_deserializeOpErrorGetDeviceRegistration(response, &metadata)
}
output := &GetDeviceRegistrationOutput{}
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_deserializeOpDocumentGetDeviceRegistrationOutput(&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_deserializeOpErrorGetDeviceRegistration(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("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetDeviceRegistrationOutput(v **GetDeviceRegistrationOutput, 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 *GetDeviceRegistrationOutput
if *v == nil {
sv = &GetDeviceRegistrationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CacheTTL":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CacheTTLSeconds to be of type string, got %T instead", value)
}
sv.CacheTTL = ptr.String(jtv)
}
case "DeviceRegistration":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DeviceRegistration to be of type string, got %T instead", value)
}
sv.DeviceRegistration = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpSendHeartbeat struct {
}
func (*awsRestjson1_deserializeOpSendHeartbeat) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpSendHeartbeat) 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_deserializeOpErrorSendHeartbeat(response, &metadata)
}
output := &SendHeartbeatOutput{}
out.Result = output
if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorSendHeartbeat(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("InternalServiceException", errorCode):
return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeErrorInternalServiceException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.InternalServiceException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, 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 err
}
err := awsRestjson1_deserializeDocumentInternalServiceException(&output, shape)
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)
return output
}
func awsRestjson1_deserializeDocumentChecksum(v **types.Checksum, 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.Checksum
if *v == nil {
sv = &types.Checksum{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Sum":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ChecksumString to be of type string, got %T instead", value)
}
sv.Sum = ptr.String(jtv)
}
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ChecksumType to be of type string, got %T instead", value)
}
sv.Type = types.ChecksumType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDefinition(v **types.Definition, 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.Definition
if *v == nil {
sv = &types.Definition{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Checksum":
if err := awsRestjson1_deserializeDocumentChecksum(&sv.Checksum, value); err != nil {
return err
}
case "ModelHandle":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EntityName to be of type string, got %T instead", value)
}
sv.ModelHandle = ptr.String(jtv)
}
case "S3Url":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected S3Uri to be of type string, got %T instead", value)
}
sv.S3Url = ptr.String(jtv)
}
case "State":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ModelState to be of type string, got %T instead", value)
}
sv.State = types.ModelState(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDefinitions(v *[]types.Definition, 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.Definition
if *v == nil {
cv = []types.Definition{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Definition
destAddr := &col
if err := awsRestjson1_deserializeDocumentDefinition(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentEdgeDeployment(v **types.EdgeDeployment, 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.EdgeDeployment
if *v == nil {
sv = &types.EdgeDeployment{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Definitions":
if err := awsRestjson1_deserializeDocumentDefinitions(&sv.Definitions, value); err != nil {
return err
}
case "DeploymentName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EntityName to be of type string, got %T instead", value)
}
sv.DeploymentName = ptr.String(jtv)
}
case "FailureHandlingPolicy":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FailureHandlingPolicy to be of type string, got %T instead", value)
}
sv.FailureHandlingPolicy = types.FailureHandlingPolicy(jtv)
}
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DeploymentType to be of type string, got %T instead", value)
}
sv.Type = types.DeploymentType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentEdgeDeployments(v *[]types.EdgeDeployment, 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.EdgeDeployment
if *v == nil {
cv = []types.EdgeDeployment{}
} else {
cv = *v
}
for _, value := range shape {
var col types.EdgeDeployment
destAddr := &col
if err := awsRestjson1_deserializeDocumentEdgeDeployment(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentInternalServiceException(v **types.InternalServiceException, 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.InternalServiceException
if *v == nil {
sv = &types.InternalServiceException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
| 736 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package sagemakeredge provides the API client, operations, and parameter types
// for Amazon Sagemaker Edge Manager.
//
// SageMaker Edge Manager dataplane service for communicating with active agents.
package sagemakeredge
| 8 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakeredge
import (
"context"
"errors"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
internalendpoints "github.com/aws/aws-sdk-go-v2/service/sagemakeredge/internal/endpoints"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net/url"
"strings"
)
// EndpointResolverOptions is the service endpoint resolver options
type EndpointResolverOptions = internalendpoints.Options
// EndpointResolver interface for resolving service endpoints.
type EndpointResolver interface {
ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
}
var _ EndpointResolver = &internalendpoints.Resolver{}
// NewDefaultEndpointResolver constructs a new service endpoint resolver
func NewDefaultEndpointResolver() *internalendpoints.Resolver {
return internalendpoints.New()
}
// 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.
type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)
func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
return fn(region, options)
}
func resolveDefaultEndpointConfiguration(o *Options) {
if o.EndpointResolver != nil {
return
}
o.EndpointResolver = NewDefaultEndpointResolver()
}
// 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.
func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver {
e := aws.Endpoint{URL: url, Source: aws.EndpointSourceCustom}
for _, fn := range optFns {
fn(&e)
}
return EndpointResolverFunc(
func(region string, options EndpointResolverOptions) (aws.Endpoint, error) {
if len(e.SigningRegion) == 0 {
e.SigningRegion = region
}
return e, nil
},
)
}
type ResolveEndpoint struct {
Resolver EndpointResolver
Options EndpointResolverOptions
}
func (*ResolveEndpoint) ID() string {
return "ResolveEndpoint"
}
func (m *ResolveEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
if m.Resolver == nil {
return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
}
eo := m.Options
eo.Logger = middleware.GetLogger(ctx)
var endpoint aws.Endpoint
endpoint, err = m.Resolver.ResolveEndpoint(awsmiddleware.GetRegion(ctx), eo)
if err != nil {
return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err)
}
req.URL, err = url.Parse(endpoint.URL)
if err != nil {
return out, metadata, fmt.Errorf("failed to parse endpoint URL: %w", err)
}
if len(awsmiddleware.GetSigningName(ctx)) == 0 {
signingName := endpoint.SigningName
if len(signingName) == 0 {
signingName = "sagemaker"
}
ctx = awsmiddleware.SetSigningName(ctx, signingName)
}
ctx = awsmiddleware.SetEndpointSource(ctx, endpoint.Source)
ctx = smithyhttp.SetHostnameImmutable(ctx, endpoint.HostnameImmutable)
ctx = awsmiddleware.SetSigningRegion(ctx, endpoint.SigningRegion)
ctx = awsmiddleware.SetPartitionID(ctx, endpoint.PartitionID)
return next.HandleSerialize(ctx, in)
}
func addResolveEndpointMiddleware(stack *middleware.Stack, o Options) error {
return stack.Serialize.Insert(&ResolveEndpoint{
Resolver: o.EndpointResolver,
Options: o.EndpointOptions,
}, "OperationSerializer", middleware.Before)
}
func removeResolveEndpointMiddleware(stack *middleware.Stack) error {
_, err := stack.Serialize.Remove((&ResolveEndpoint{}).ID())
return err
}
type wrappedEndpointResolver struct {
awsResolver aws.EndpointResolverWithOptions
resolver EndpointResolver
}
func (w *wrappedEndpointResolver) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
if w.awsResolver == nil {
goto fallback
}
endpoint, err = w.awsResolver.ResolveEndpoint(ServiceID, region, options)
if err == nil {
return endpoint, nil
}
if nf := (&aws.EndpointNotFoundError{}); !errors.As(err, &nf) {
return endpoint, err
}
fallback:
if w.resolver == nil {
return endpoint, fmt.Errorf("default endpoint resolver provided was nil")
}
return w.resolver.ResolveEndpoint(region, options)
}
type awsEndpointResolverAdaptor func(service, region string) (aws.Endpoint, error)
func (a awsEndpointResolverAdaptor) ResolveEndpoint(service, region string, options ...interface{}) (aws.Endpoint, error) {
return a(service, region)
}
var _ aws.EndpointResolverWithOptions = awsEndpointResolverAdaptor(nil)
// withEndpointResolver returns an EndpointResolver that first delegates endpoint resolution to the awsResolver.
// If awsResolver returns aws.EndpointNotFoundError error, the resolver will use the the provided
// fallbackResolver for resolution.
//
// fallbackResolver must not be nil
func withEndpointResolver(awsResolver aws.EndpointResolver, awsResolverWithOptions aws.EndpointResolverWithOptions, fallbackResolver EndpointResolver) EndpointResolver {
var resolver aws.EndpointResolverWithOptions
if awsResolverWithOptions != nil {
resolver = awsResolverWithOptions
} else if awsResolver != nil {
resolver = awsEndpointResolverAdaptor(awsResolver.ResolveEndpoint)
}
return &wrappedEndpointResolver{
awsResolver: resolver,
resolver: fallbackResolver,
}
}
func finalizeClientEndpointResolverOptions(options *Options) {
options.EndpointOptions.LogDeprecated = options.ClientLogMode.IsDeprecatedUsage()
if len(options.EndpointOptions.ResolvedRegion) == 0 {
const fipsInfix = "-fips-"
const fipsPrefix = "fips-"
const fipsSuffix = "-fips"
if strings.Contains(options.Region, fipsInfix) ||
strings.Contains(options.Region, fipsPrefix) ||
strings.Contains(options.Region, fipsSuffix) {
options.EndpointOptions.ResolvedRegion = strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(
options.Region, fipsInfix, "-"), fipsPrefix, ""), fipsSuffix, "")
options.EndpointOptions.UseFIPSEndpoint = aws.FIPSEndpointStateEnabled
}
}
}
| 201 |
aws-sdk-go-v2 | aws | Go | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT.
package sagemakeredge
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.13.12"
| 7 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakeredge
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakeredge
import (
"bytes"
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/sagemakeredge/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/encoding/httpbinding"
smithyjson "github.com/aws/smithy-go/encoding/json"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
"math"
)
type awsRestjson1_serializeOpGetDeployments struct {
}
func (*awsRestjson1_serializeOpGetDeployments) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetDeployments) 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.(*GetDeploymentsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/GetDeployments")
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_serializeOpDocumentGetDeploymentsInput(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_serializeOpHttpBindingsGetDeploymentsInput(v *GetDeploymentsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGetDeploymentsInput(v *GetDeploymentsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DeviceFleetName != nil {
ok := object.Key("DeviceFleetName")
ok.String(*v.DeviceFleetName)
}
if v.DeviceName != nil {
ok := object.Key("DeviceName")
ok.String(*v.DeviceName)
}
return nil
}
type awsRestjson1_serializeOpGetDeviceRegistration struct {
}
func (*awsRestjson1_serializeOpGetDeviceRegistration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetDeviceRegistration) 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.(*GetDeviceRegistrationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/GetDeviceRegistration")
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_serializeOpDocumentGetDeviceRegistrationInput(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_serializeOpHttpBindingsGetDeviceRegistrationInput(v *GetDeviceRegistrationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGetDeviceRegistrationInput(v *GetDeviceRegistrationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DeviceFleetName != nil {
ok := object.Key("DeviceFleetName")
ok.String(*v.DeviceFleetName)
}
if v.DeviceName != nil {
ok := object.Key("DeviceName")
ok.String(*v.DeviceName)
}
return nil
}
type awsRestjson1_serializeOpSendHeartbeat struct {
}
func (*awsRestjson1_serializeOpSendHeartbeat) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpSendHeartbeat) 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.(*SendHeartbeatInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/SendHeartbeat")
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_serializeOpDocumentSendHeartbeatInput(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_serializeOpHttpBindingsSendHeartbeatInput(v *SendHeartbeatInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentSendHeartbeatInput(v *SendHeartbeatInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AgentMetrics != nil {
ok := object.Key("AgentMetrics")
if err := awsRestjson1_serializeDocumentEdgeMetrics(v.AgentMetrics, ok); err != nil {
return err
}
}
if v.AgentVersion != nil {
ok := object.Key("AgentVersion")
ok.String(*v.AgentVersion)
}
if v.DeploymentResult != nil {
ok := object.Key("DeploymentResult")
if err := awsRestjson1_serializeDocumentDeploymentResult(v.DeploymentResult, ok); err != nil {
return err
}
}
if v.DeviceFleetName != nil {
ok := object.Key("DeviceFleetName")
ok.String(*v.DeviceFleetName)
}
if v.DeviceName != nil {
ok := object.Key("DeviceName")
ok.String(*v.DeviceName)
}
if v.Models != nil {
ok := object.Key("Models")
if err := awsRestjson1_serializeDocumentModels(v.Models, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentDeploymentModel(v *types.DeploymentModel, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.DesiredState) > 0 {
ok := object.Key("DesiredState")
ok.String(string(v.DesiredState))
}
if v.ModelHandle != nil {
ok := object.Key("ModelHandle")
ok.String(*v.ModelHandle)
}
if v.ModelName != nil {
ok := object.Key("ModelName")
ok.String(*v.ModelName)
}
if v.ModelVersion != nil {
ok := object.Key("ModelVersion")
ok.String(*v.ModelVersion)
}
if v.RollbackFailureReason != nil {
ok := object.Key("RollbackFailureReason")
ok.String(*v.RollbackFailureReason)
}
if len(v.State) > 0 {
ok := object.Key("State")
ok.String(string(v.State))
}
if len(v.Status) > 0 {
ok := object.Key("Status")
ok.String(string(v.Status))
}
if v.StatusReason != nil {
ok := object.Key("StatusReason")
ok.String(*v.StatusReason)
}
return nil
}
func awsRestjson1_serializeDocumentDeploymentModels(v []types.DeploymentModel, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentDeploymentModel(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentDeploymentResult(v *types.DeploymentResult, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DeploymentEndTime != nil {
ok := object.Key("DeploymentEndTime")
ok.Double(smithytime.FormatEpochSeconds(*v.DeploymentEndTime))
}
if v.DeploymentModels != nil {
ok := object.Key("DeploymentModels")
if err := awsRestjson1_serializeDocumentDeploymentModels(v.DeploymentModels, ok); err != nil {
return err
}
}
if v.DeploymentName != nil {
ok := object.Key("DeploymentName")
ok.String(*v.DeploymentName)
}
if v.DeploymentStartTime != nil {
ok := object.Key("DeploymentStartTime")
ok.Double(smithytime.FormatEpochSeconds(*v.DeploymentStartTime))
}
if v.DeploymentStatus != nil {
ok := object.Key("DeploymentStatus")
ok.String(*v.DeploymentStatus)
}
if v.DeploymentStatusMessage != nil {
ok := object.Key("DeploymentStatusMessage")
ok.String(*v.DeploymentStatusMessage)
}
return nil
}
func awsRestjson1_serializeDocumentEdgeMetric(v *types.EdgeMetric, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Dimension != nil {
ok := object.Key("Dimension")
ok.String(*v.Dimension)
}
if v.MetricName != nil {
ok := object.Key("MetricName")
ok.String(*v.MetricName)
}
if v.Timestamp != nil {
ok := object.Key("Timestamp")
ok.Double(smithytime.FormatEpochSeconds(*v.Timestamp))
}
if v.Value != 0 {
ok := object.Key("Value")
switch {
case math.IsNaN(v.Value):
ok.String("NaN")
case math.IsInf(v.Value, 1):
ok.String("Infinity")
case math.IsInf(v.Value, -1):
ok.String("-Infinity")
default:
ok.Double(v.Value)
}
}
return nil
}
func awsRestjson1_serializeDocumentEdgeMetrics(v []types.EdgeMetric, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentEdgeMetric(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentModel(v *types.Model, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LatestInference != nil {
ok := object.Key("LatestInference")
ok.Double(smithytime.FormatEpochSeconds(*v.LatestInference))
}
if v.LatestSampleTime != nil {
ok := object.Key("LatestSampleTime")
ok.Double(smithytime.FormatEpochSeconds(*v.LatestSampleTime))
}
if v.ModelMetrics != nil {
ok := object.Key("ModelMetrics")
if err := awsRestjson1_serializeDocumentEdgeMetrics(v.ModelMetrics, ok); err != nil {
return err
}
}
if v.ModelName != nil {
ok := object.Key("ModelName")
ok.String(*v.ModelName)
}
if v.ModelVersion != nil {
ok := object.Key("ModelVersion")
ok.String(*v.ModelVersion)
}
return nil
}
func awsRestjson1_serializeDocumentModels(v []types.Model, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentModel(&v[i], av); err != nil {
return err
}
}
return nil
}
| 462 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakeredge
import (
"context"
"fmt"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpGetDeployments struct {
}
func (*validateOpGetDeployments) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetDeployments) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetDeploymentsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetDeploymentsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetDeviceRegistration struct {
}
func (*validateOpGetDeviceRegistration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetDeviceRegistration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetDeviceRegistrationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetDeviceRegistrationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpSendHeartbeat struct {
}
func (*validateOpSendHeartbeat) ID() string {
return "OperationInputValidation"
}
func (m *validateOpSendHeartbeat) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*SendHeartbeatInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpSendHeartbeatInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpGetDeploymentsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetDeployments{}, middleware.After)
}
func addOpGetDeviceRegistrationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetDeviceRegistration{}, middleware.After)
}
func addOpSendHeartbeatValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpSendHeartbeat{}, middleware.After)
}
func validateOpGetDeploymentsInput(v *GetDeploymentsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetDeploymentsInput"}
if v.DeviceName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DeviceName"))
}
if v.DeviceFleetName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DeviceFleetName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetDeviceRegistrationInput(v *GetDeviceRegistrationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetDeviceRegistrationInput"}
if v.DeviceName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DeviceName"))
}
if v.DeviceFleetName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DeviceFleetName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpSendHeartbeatInput(v *SendHeartbeatInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SendHeartbeatInput"}
if v.AgentVersion == nil {
invalidParams.Add(smithy.NewErrParamRequired("AgentVersion"))
}
if v.DeviceName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DeviceName"))
}
if v.DeviceFleetName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DeviceFleetName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 140 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"github.com/aws/aws-sdk-go-v2/aws"
endpoints "github.com/aws/aws-sdk-go-v2/internal/endpoints/v2"
"github.com/aws/smithy-go/logging"
"regexp"
)
// Options is the endpoint resolver configuration options
type Options struct {
// Logger is a logging implementation that log events should be sent to.
Logger logging.Logger
// LogDeprecated indicates that deprecated endpoints should be logged to the
// provided logger.
LogDeprecated bool
// ResolvedRegion is used to override the region to be resolved, rather then the
// using the value passed to the ResolveEndpoint method. This value is used by the
// SDK to translate regions like fips-us-east-1 or us-east-1-fips to an alternative
// name. You must not set this value directly in your application.
ResolvedRegion string
// DisableHTTPS informs the resolver to return an endpoint that does not use the
// HTTPS scheme.
DisableHTTPS bool
// UseDualStackEndpoint specifies the resolver must resolve a dual-stack endpoint.
UseDualStackEndpoint aws.DualStackEndpointState
// UseFIPSEndpoint specifies the resolver must resolve a FIPS endpoint.
UseFIPSEndpoint aws.FIPSEndpointState
}
func (o Options) GetResolvedRegion() string {
return o.ResolvedRegion
}
func (o Options) GetDisableHTTPS() bool {
return o.DisableHTTPS
}
func (o Options) GetUseDualStackEndpoint() aws.DualStackEndpointState {
return o.UseDualStackEndpoint
}
func (o Options) GetUseFIPSEndpoint() aws.FIPSEndpointState {
return o.UseFIPSEndpoint
}
func transformToSharedOptions(options Options) endpoints.Options {
return endpoints.Options{
Logger: options.Logger,
LogDeprecated: options.LogDeprecated,
ResolvedRegion: options.ResolvedRegion,
DisableHTTPS: options.DisableHTTPS,
UseDualStackEndpoint: options.UseDualStackEndpoint,
UseFIPSEndpoint: options.UseFIPSEndpoint,
}
}
// Resolver Sagemaker Edge endpoint resolver
type Resolver struct {
partitions endpoints.Partitions
}
// ResolveEndpoint resolves the service endpoint for the given region and options
func (r *Resolver) ResolveEndpoint(region string, options Options) (endpoint aws.Endpoint, err error) {
if len(region) == 0 {
return endpoint, &aws.MissingRegionError{}
}
opt := transformToSharedOptions(options)
return r.partitions.ResolveEndpoint(region, opt)
}
// New returns a new Resolver
func New() *Resolver {
return &Resolver{
partitions: defaultPartitions,
}
}
var partitionRegexp = struct {
Aws *regexp.Regexp
AwsCn *regexp.Regexp
AwsIso *regexp.Regexp
AwsIsoB *regexp.Regexp
AwsIsoE *regexp.Regexp
AwsIsoF *regexp.Regexp
AwsUsGov *regexp.Regexp
}{
Aws: regexp.MustCompile("^(us|eu|ap|sa|ca|me|af)\\-\\w+\\-\\d+$"),
AwsCn: regexp.MustCompile("^cn\\-\\w+\\-\\d+$"),
AwsIso: regexp.MustCompile("^us\\-iso\\-\\w+\\-\\d+$"),
AwsIsoB: regexp.MustCompile("^us\\-isob\\-\\w+\\-\\d+$"),
AwsIsoE: regexp.MustCompile("^eu\\-isoe\\-\\w+\\-\\d+$"),
AwsIsoF: regexp.MustCompile("^us\\-isof\\-\\w+\\-\\d+$"),
AwsUsGov: regexp.MustCompile("^us\\-gov\\-\\w+\\-\\d+$"),
}
var defaultPartitions = endpoints.Partitions{
{
ID: "aws",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "edge.sagemaker.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "edge.sagemaker-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "edge.sagemaker-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "edge.sagemaker.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.Aws,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "ap-northeast-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-central-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-east-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-west-2",
}: endpoints.Endpoint{},
},
},
{
ID: "aws-cn",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "edge.sagemaker.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "edge.sagemaker-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "edge.sagemaker-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "edge.sagemaker.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsCn,
IsRegionalized: true,
},
{
ID: "aws-iso",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "edge.sagemaker-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "edge.sagemaker.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIso,
IsRegionalized: true,
},
{
ID: "aws-iso-b",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "edge.sagemaker-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "edge.sagemaker.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoB,
IsRegionalized: true,
},
{
ID: "aws-iso-e",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "edge.sagemaker-fips.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "edge.sagemaker.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoE,
IsRegionalized: true,
},
{
ID: "aws-iso-f",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "edge.sagemaker-fips.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "edge.sagemaker.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoF,
IsRegionalized: true,
},
{
ID: "aws-us-gov",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "edge.sagemaker.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "edge.sagemaker-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "edge.sagemaker-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "edge.sagemaker.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: true,
},
}
| 317 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"testing"
)
func TestRegexCompile(t *testing.T) {
_ = defaultPartitions
}
| 12 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
type ChecksumType string
// Enum values for ChecksumType
const (
ChecksumTypeSha1 ChecksumType = "SHA1"
)
// Values returns all known values for ChecksumType. 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 (ChecksumType) Values() []ChecksumType {
return []ChecksumType{
"SHA1",
}
}
type DeploymentStatus string
// Enum values for DeploymentStatus
const (
DeploymentStatusSuccess DeploymentStatus = "SUCCESS"
DeploymentStatusFail DeploymentStatus = "FAIL"
)
// Values returns all known values for DeploymentStatus. 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 (DeploymentStatus) Values() []DeploymentStatus {
return []DeploymentStatus{
"SUCCESS",
"FAIL",
}
}
type DeploymentType string
// Enum values for DeploymentType
const (
DeploymentTypeModel DeploymentType = "Model"
)
// Values returns all known values for DeploymentType. 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 (DeploymentType) Values() []DeploymentType {
return []DeploymentType{
"Model",
}
}
type FailureHandlingPolicy string
// Enum values for FailureHandlingPolicy
const (
FailureHandlingPolicyRollbackOnFailure FailureHandlingPolicy = "ROLLBACK_ON_FAILURE"
FailureHandlingPolicyDoNothing FailureHandlingPolicy = "DO_NOTHING"
)
// Values returns all known values for FailureHandlingPolicy. 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 (FailureHandlingPolicy) Values() []FailureHandlingPolicy {
return []FailureHandlingPolicy{
"ROLLBACK_ON_FAILURE",
"DO_NOTHING",
}
}
type ModelState string
// Enum values for ModelState
const (
ModelStateDeploy ModelState = "DEPLOY"
ModelStateUndeploy ModelState = "UNDEPLOY"
)
// Values returns all known values for ModelState. 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 (ModelState) Values() []ModelState {
return []ModelState{
"DEPLOY",
"UNDEPLOY",
}
}
| 90 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
"fmt"
smithy "github.com/aws/smithy-go"
)
// An internal failure occurred. Try your request again. If the problem persists,
// contact Amazon Web Services customer support.
type InternalServiceException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InternalServiceException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InternalServiceException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InternalServiceException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InternalServiceException"
}
return *e.ErrorCodeOverride
}
func (e *InternalServiceException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
| 36 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
smithydocument "github.com/aws/smithy-go/document"
"time"
)
// Information about the checksum of a model deployed on a device.
type Checksum struct {
// The checksum of the model.
Sum *string
// The type of the checksum.
Type ChecksumType
noSmithyDocumentSerde
}
type Definition struct {
// The checksum information of the model.
Checksum *Checksum
// The unique model handle.
ModelHandle *string
// The absolute S3 location of the model.
S3Url *string
// The desired state of the model.
State ModelState
noSmithyDocumentSerde
}
type DeploymentModel struct {
// The desired state of the model.
DesiredState ModelState
// The unique handle of the model.
ModelHandle *string
// The name of the model.
ModelName *string
// The version of the model.
ModelVersion *string
// Returns the error message if there is a rollback.
RollbackFailureReason *string
// Returns the current state of the model.
State ModelState
// Returns the deployment status of the model.
Status DeploymentStatus
// Returns the error message for the deployment status result.
StatusReason *string
noSmithyDocumentSerde
}
// Information about the result of a deployment on an edge device that is
// registered with SageMaker Edge Manager.
type DeploymentResult struct {
// The timestamp of when the deployment was ended, and the agent got the
// deployment results.
DeploymentEndTime *time.Time
// Returns a list of models deployed on the agent.
DeploymentModels []DeploymentModel
// The name and unique ID of the deployment.
DeploymentName *string
// The timestamp of when the deployment was started on the agent.
DeploymentStartTime *time.Time
// Returns the bucket error code.
DeploymentStatus *string
// Returns the detailed error message.
DeploymentStatusMessage *string
noSmithyDocumentSerde
}
// Information about a deployment on an edge device that is registered with
// SageMaker Edge Manager.
type EdgeDeployment struct {
// Returns a list of Definition objects.
Definitions []Definition
// The name and unique ID of the deployment.
DeploymentName *string
// Determines whether to rollback to previous configuration if deployment fails.
FailureHandlingPolicy FailureHandlingPolicy
// The type of the deployment.
Type DeploymentType
noSmithyDocumentSerde
}
// Information required for edge device metrics.
type EdgeMetric struct {
// The dimension of metrics published.
Dimension *string
// Returns the name of the metric.
MetricName *string
// Timestamp of when the metric was requested.
Timestamp *time.Time
// Returns the value of the metric.
Value float64
noSmithyDocumentSerde
}
// Information about a model deployed on an edge device that is registered with
// SageMaker Edge Manager.
type Model struct {
// The timestamp of the last inference that was made.
LatestInference *time.Time
// The timestamp of the last data sample taken.
LatestSampleTime *time.Time
// Information required for model metrics.
ModelMetrics []EdgeMetric
// The name of the model.
ModelName *string
// The version of the model.
ModelVersion *string
noSmithyDocumentSerde
}
type noSmithyDocumentSerde = smithydocument.NoSerde
| 154 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerfeaturestoreruntime
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/aws/defaults"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/retry"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources"
smithy "github.com/aws/smithy-go"
smithydocument "github.com/aws/smithy-go/document"
"github.com/aws/smithy-go/logging"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net"
"net/http"
"time"
)
const ServiceID = "SageMaker FeatureStore Runtime"
const ServiceAPIVersion = "2020-07-01"
// Client provides the API client to make operations call for Amazon SageMaker
// Feature Store Runtime.
type Client struct {
options Options
}
// 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 New(options Options, optFns ...func(*Options)) *Client {
options = options.Copy()
resolveDefaultLogger(&options)
setResolvedDefaultsMode(&options)
resolveRetryer(&options)
resolveHTTPClient(&options)
resolveHTTPSignerV4(&options)
resolveDefaultEndpointConfiguration(&options)
for _, fn := range optFns {
fn(&options)
}
client := &Client{
options: options,
}
return client
}
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 configuration DefaultsMode that the SDK should use when constructing the
// clients initial default settings.
DefaultsMode aws.DefaultsMode
// 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
// RetryMaxAttempts specifies the maximum number attempts an API client will call
// an operation that fails with a retryable error. A value of 0 is ignored, and
// will not be used to configure the API client created default retryer, or modify
// per operation call's retry max attempts. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. If specified in an operation call's functional
// options with a value that is different than the constructed client's Options,
// the Client's Retryer will be wrapped to use the operation's specific
// RetryMaxAttempts value.
RetryMaxAttempts int
// RetryMode specifies the retry mode the API client will be created with, if
// Retryer option is not also specified. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. Currently does not support per operation call
// overrides, may in the future.
RetryMode aws.RetryMode
// Retryer guides how HTTP requests should be retried in case of recoverable
// failures. When nil the API client will use a default retryer. The kind of
// default retry created by the API client can be changed with the RetryMode
// option.
Retryer aws.Retryer
// The RuntimeEnvironment configuration, only populated if the DefaultsMode is set
// to DefaultsModeAuto and is initialized using config.LoadDefaultConfig . You
// should not populate this structure programmatically, or rely on the values here
// within your applications.
RuntimeEnvironment aws.RuntimeEnvironment
// The initial DefaultsMode used when the client options were constructed. If the
// DefaultsMode was set to aws.DefaultsModeAuto this will store what the resolved
// value was at that point in time. Currently does not support per operation call
// overrides, may in the future.
resolvedDefaultsMode aws.DefaultsMode
// The HTTP client to invoke API calls with. Defaults to client's default HTTP
// implementation if nil.
HTTPClient HTTPClient
}
// WithAPIOptions returns a functional option for setting the Client's APIOptions
// option.
func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options) {
return func(o *Options) {
o.APIOptions = append(o.APIOptions, optFns...)
}
}
// WithEndpointResolver returns a functional option for setting the Client's
// EndpointResolver option.
func WithEndpointResolver(v EndpointResolver) func(*Options) {
return func(o *Options) {
o.EndpointResolver = v
}
}
type HTTPClient interface {
Do(*http.Request) (*http.Response, error)
}
// Copy creates a clone where the APIOptions list is deep copied.
func (o Options) Copy() Options {
to := o
to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions))
copy(to.APIOptions, o.APIOptions)
return to
}
func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) {
ctx = middleware.ClearStackValues(ctx)
stack := middleware.NewStack(opID, smithyhttp.NewStackRequest)
options := c.options.Copy()
for _, fn := range optFns {
fn(&options)
}
finalizeRetryMaxAttemptOptions(&options, *c)
finalizeClientEndpointResolverOptions(&options)
for _, fn := range stackFns {
if err := fn(stack, options); err != nil {
return nil, metadata, err
}
}
for _, fn := range options.APIOptions {
if err := fn(stack); err != nil {
return nil, metadata, err
}
}
handler := middleware.DecorateHandler(smithyhttp.NewClientHandler(options.HTTPClient), stack)
result, metadata, err = handler.Handle(ctx, params)
if err != nil {
err = &smithy.OperationError{
ServiceID: ServiceID,
OperationName: opID,
Err: err,
}
}
return result, metadata, err
}
type noSmithyDocumentSerde = smithydocument.NoSerde
func resolveDefaultLogger(o *Options) {
if o.Logger != nil {
return
}
o.Logger = logging.Nop{}
}
func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error {
return middleware.AddSetLoggerMiddleware(stack, o.Logger)
}
func setResolvedDefaultsMode(o *Options) {
if len(o.resolvedDefaultsMode) > 0 {
return
}
var mode aws.DefaultsMode
mode.SetFromString(string(o.DefaultsMode))
if mode == aws.DefaultsModeAuto {
mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment)
}
o.resolvedDefaultsMode = mode
}
// NewFromConfig returns a new client from the provided config.
func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client {
opts := Options{
Region: cfg.Region,
DefaultsMode: cfg.DefaultsMode,
RuntimeEnvironment: cfg.RuntimeEnvironment,
HTTPClient: cfg.HTTPClient,
Credentials: cfg.Credentials,
APIOptions: cfg.APIOptions,
Logger: cfg.Logger,
ClientLogMode: cfg.ClientLogMode,
}
resolveAWSRetryerProvider(cfg, &opts)
resolveAWSRetryMaxAttempts(cfg, &opts)
resolveAWSRetryMode(cfg, &opts)
resolveAWSEndpointResolver(cfg, &opts)
resolveUseDualStackEndpoint(cfg, &opts)
resolveUseFIPSEndpoint(cfg, &opts)
return New(opts, optFns...)
}
func resolveHTTPClient(o *Options) {
var buildable *awshttp.BuildableClient
if o.HTTPClient != nil {
var ok bool
buildable, ok = o.HTTPClient.(*awshttp.BuildableClient)
if !ok {
return
}
} else {
buildable = awshttp.NewBuildableClient()
}
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) {
if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok {
dialer.Timeout = dialerTimeout
}
})
buildable = buildable.WithTransportOptions(func(transport *http.Transport) {
if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok {
transport.TLSHandshakeTimeout = tlsHandshakeTimeout
}
})
}
o.HTTPClient = buildable
}
func resolveRetryer(o *Options) {
if o.Retryer != nil {
return
}
if len(o.RetryMode) == 0 {
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
o.RetryMode = modeConfig.RetryMode
}
}
if len(o.RetryMode) == 0 {
o.RetryMode = aws.RetryModeStandard
}
var standardOptions []func(*retry.StandardOptions)
if v := o.RetryMaxAttempts; v != 0 {
standardOptions = append(standardOptions, func(so *retry.StandardOptions) {
so.MaxAttempts = v
})
}
switch o.RetryMode {
case aws.RetryModeAdaptive:
var adaptiveOptions []func(*retry.AdaptiveModeOptions)
if len(standardOptions) != 0 {
adaptiveOptions = append(adaptiveOptions, func(ao *retry.AdaptiveModeOptions) {
ao.StandardOptions = append(ao.StandardOptions, standardOptions...)
})
}
o.Retryer = retry.NewAdaptiveMode(adaptiveOptions...)
default:
o.Retryer = retry.NewStandard(standardOptions...)
}
}
func resolveAWSRetryerProvider(cfg aws.Config, o *Options) {
if cfg.Retryer == nil {
return
}
o.Retryer = cfg.Retryer()
}
func resolveAWSRetryMode(cfg aws.Config, o *Options) {
if len(cfg.RetryMode) == 0 {
return
}
o.RetryMode = cfg.RetryMode
}
func resolveAWSRetryMaxAttempts(cfg aws.Config, o *Options) {
if cfg.RetryMaxAttempts == 0 {
return
}
o.RetryMaxAttempts = cfg.RetryMaxAttempts
}
func finalizeRetryMaxAttemptOptions(o *Options, client Client) {
if v := o.RetryMaxAttempts; v == 0 || v == client.options.RetryMaxAttempts {
return
}
o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts)
}
func resolveAWSEndpointResolver(cfg aws.Config, o *Options) {
if cfg.EndpointResolver == nil && cfg.EndpointResolverWithOptions == nil {
return
}
o.EndpointResolver = withEndpointResolver(cfg.EndpointResolver, cfg.EndpointResolverWithOptions, NewDefaultEndpointResolver())
}
func addClientUserAgent(stack *middleware.Stack) error {
return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "sagemakerfeaturestoreruntime", goModuleVersion)(stack)
}
func addHTTPSignerV4Middleware(stack *middleware.Stack, o Options) error {
mw := v4.NewSignHTTPRequestMiddleware(v4.SignHTTPRequestMiddlewareOptions{
CredentialsProvider: o.Credentials,
Signer: o.HTTPSignerV4,
LogSigning: o.ClientLogMode.IsSigning(),
})
return stack.Finalize.Add(mw, middleware.After)
}
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
}
func resolveHTTPSignerV4(o *Options) {
if o.HTTPSignerV4 != nil {
return
}
o.HTTPSignerV4 = newDefaultV4Signer(*o)
}
func newDefaultV4Signer(o Options) *v4.Signer {
return v4.NewSigner(func(so *v4.SignerOptions) {
so.Logger = o.Logger
so.LogSigning = o.ClientLogMode.IsSigning()
})
}
func addRetryMiddlewares(stack *middleware.Stack, o Options) error {
mo := retry.AddRetryMiddlewaresOptions{
Retryer: o.Retryer,
LogRetryAttempts: o.ClientLogMode.IsRetries(),
}
return retry.AddRetryMiddlewares(stack, mo)
}
// resolves dual-stack endpoint configuration
func resolveUseDualStackEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseDualStackEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseDualStackEndpoint = value
}
return nil
}
// resolves FIPS endpoint configuration
func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseFIPSEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseFIPSEndpoint = value
}
return nil
}
func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error {
return awsmiddleware.AddRequestIDRetrieverMiddleware(stack)
}
func addResponseErrorMiddleware(stack *middleware.Stack) error {
return awshttp.AddResponseErrorMiddleware(stack)
}
func addRequestResponseLogging(stack *middleware.Stack, o Options) error {
return stack.Deserialize.Add(&smithyhttp.RequestResponseLogger{
LogRequest: o.ClientLogMode.IsRequest(),
LogRequestWithBody: o.ClientLogMode.IsRequestWithBody(),
LogResponse: o.ClientLogMode.IsResponse(),
LogResponseWithBody: o.ClientLogMode.IsResponseWithBody(),
}, middleware.After)
}
| 435 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerfeaturestoreruntime
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io/ioutil"
"net/http"
"strings"
"testing"
)
func TestClient_resolveRetryOptions(t *testing.T) {
nopClient := smithyhttp.ClientDoFunc(func(_ *http.Request) (*http.Response, error) {
return &http.Response{
StatusCode: 200,
Header: http.Header{},
Body: ioutil.NopCloser(strings.NewReader("")),
}, nil
})
cases := map[string]struct {
defaultsMode aws.DefaultsMode
retryer aws.Retryer
retryMaxAttempts int
opRetryMaxAttempts *int
retryMode aws.RetryMode
expectClientRetryMode aws.RetryMode
expectClientMaxAttempts int
expectOpMaxAttempts int
}{
"defaults": {
defaultsMode: aws.DefaultsModeStandard,
expectClientRetryMode: aws.RetryModeStandard,
expectClientMaxAttempts: 3,
expectOpMaxAttempts: 3,
},
"custom default retry": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(2),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 2,
},
"custom op no change max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(10),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op 0 max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(0),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
client := NewFromConfig(aws.Config{
DefaultsMode: c.defaultsMode,
Retryer: func() func() aws.Retryer {
if c.retryer == nil {
return nil
}
return func() aws.Retryer { return c.retryer }
}(),
HTTPClient: nopClient,
RetryMaxAttempts: c.retryMaxAttempts,
RetryMode: c.retryMode,
})
if e, a := c.expectClientRetryMode, client.options.RetryMode; e != a {
t.Errorf("expect %v retry mode, got %v", e, a)
}
if e, a := c.expectClientMaxAttempts, client.options.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v max attempts, got %v", e, a)
}
_, _, err := client.invokeOperation(context.Background(), "mockOperation", struct{}{},
[]func(*Options){
func(o *Options) {
if c.opRetryMaxAttempts == nil {
return
}
o.RetryMaxAttempts = *c.opRetryMaxAttempts
},
},
func(s *middleware.Stack, o Options) error {
s.Initialize.Clear()
s.Serialize.Clear()
s.Build.Clear()
s.Finalize.Clear()
s.Deserialize.Clear()
if e, a := c.expectOpMaxAttempts, o.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v op max attempts, got %v", e, a)
}
return nil
})
if err != nil {
t.Fatalf("expect no operation error, got %v", err)
}
})
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerfeaturestoreruntime
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/aws-sdk-go-v2/service/sagemakerfeaturestoreruntime/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a batch of Records from a FeatureGroup .
func (c *Client) BatchGetRecord(ctx context.Context, params *BatchGetRecordInput, optFns ...func(*Options)) (*BatchGetRecordOutput, error) {
if params == nil {
params = &BatchGetRecordInput{}
}
result, metadata, err := c.invokeOperation(ctx, "BatchGetRecord", params, optFns, c.addOperationBatchGetRecordMiddlewares)
if err != nil {
return nil, err
}
out := result.(*BatchGetRecordOutput)
out.ResultMetadata = metadata
return out, nil
}
type BatchGetRecordInput struct {
// A list of FeatureGroup names, with their corresponding RecordIdentifier value,
// and Feature name that have been requested to be retrieved in batch.
//
// This member is required.
Identifiers []types.BatchGetRecordIdentifier
// Parameter to request ExpiresAt in response. If Enabled , BatchGetRecord will
// return the value of ExpiresAt , if it is not null. If Disabled and null,
// BatchGetRecord will return null.
ExpirationTimeResponse types.ExpirationTimeResponse
noSmithyDocumentSerde
}
type BatchGetRecordOutput struct {
// A list of errors that have occurred when retrieving a batch of Records.
//
// This member is required.
Errors []types.BatchGetRecordError
// A list of Records you requested to be retrieved in batch.
//
// This member is required.
Records []types.BatchGetRecordResultDetail
// A unprocessed list of FeatureGroup names, with their corresponding
// RecordIdentifier value, and Feature name.
//
// This member is required.
UnprocessedIdentifiers []types.BatchGetRecordIdentifier
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationBatchGetRecordMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpBatchGetRecord{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpBatchGetRecord{}, 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 = addOpBatchGetRecordValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opBatchGetRecord(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_opBatchGetRecord(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "BatchGetRecord",
}
}
| 144 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerfeaturestoreruntime
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/aws-sdk-go-v2/service/sagemakerfeaturestoreruntime/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a Record from a FeatureGroup in the OnlineStore . Feature Store supports
// both SoftDelete and HardDelete . For SoftDelete (default), feature columns are
// set to null and the record is no longer retrievable by GetRecord or
// BatchGetRecord . For HardDelete , the complete Record is removed from the
// OnlineStore . In both cases, Feature Store appends the deleted record marker to
// the OfflineStore with feature values set to null , is_deleted value set to True
// , and EventTime set to the delete input EventTime . Note that the EventTime
// specified in DeleteRecord should be set later than the EventTime of the
// existing record in the OnlineStore for that RecordIdentifer . If it is not, the
// deletion does not occur:
// - For SoftDelete , the existing (undeleted) record remains in the OnlineStore
// , though the delete record marker is still written to the OfflineStore .
// - HardDelete returns EventTime : 400 ValidationException to indicate that the
// delete operation failed. No delete record marker is written to the
// OfflineStore .
func (c *Client) DeleteRecord(ctx context.Context, params *DeleteRecordInput, optFns ...func(*Options)) (*DeleteRecordOutput, error) {
if params == nil {
params = &DeleteRecordInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteRecord", params, optFns, c.addOperationDeleteRecordMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteRecordOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteRecordInput struct {
// Timestamp indicating when the deletion event occurred. EventTime can be used to
// query data at a certain point in time.
//
// This member is required.
EventTime *string
// The name of the feature group to delete the record from.
//
// This member is required.
FeatureGroupName *string
// The value for the RecordIdentifier that uniquely identifies the record, in
// string format.
//
// This member is required.
RecordIdentifierValueAsString *string
// The name of the deletion mode for deleting the record. By default, the deletion
// mode is set to SoftDelete .
DeletionMode types.DeletionMode
// A list of stores from which you're deleting the record. By default, Feature
// Store deletes the record from all of the stores that you're using for the
// FeatureGroup .
TargetStores []types.TargetStore
noSmithyDocumentSerde
}
type DeleteRecordOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteRecordMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteRecord{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteRecord{}, 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 = addOpDeleteRecordValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteRecord(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_opDeleteRecord(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteRecord",
}
}
| 156 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerfeaturestoreruntime
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/aws-sdk-go-v2/service/sagemakerfeaturestoreruntime/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Use for OnlineStore serving from a FeatureStore . Only the latest records stored
// in the OnlineStore can be retrieved. If no Record with RecordIdentifierValue is
// found, then an empty result is returned.
func (c *Client) GetRecord(ctx context.Context, params *GetRecordInput, optFns ...func(*Options)) (*GetRecordOutput, error) {
if params == nil {
params = &GetRecordInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetRecord", params, optFns, c.addOperationGetRecordMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetRecordOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetRecordInput struct {
// The name of the feature group from which you want to retrieve a record.
//
// This member is required.
FeatureGroupName *string
// The value that corresponds to RecordIdentifier type and uniquely identifies the
// record in the FeatureGroup .
//
// This member is required.
RecordIdentifierValueAsString *string
// Parameter to request ExpiresAt in response. If Enabled , BatchGetRecord will
// return the value of ExpiresAt , if it is not null. If Disabled and null,
// BatchGetRecord will return null.
ExpirationTimeResponse types.ExpirationTimeResponse
// List of names of Features to be retrieved. If not specified, the latest value
// for all the Features are returned.
FeatureNames []string
noSmithyDocumentSerde
}
type GetRecordOutput struct {
// The ExpiresAt ISO string of the requested record.
ExpiresAt *string
// The record you requested. A list of FeatureValues .
Record []types.FeatureValue
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetRecordMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetRecord{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetRecord{}, 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 = addOpGetRecordValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetRecord(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_opGetRecord(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "GetRecord",
}
}
| 145 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerfeaturestoreruntime
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/aws-sdk-go-v2/service/sagemakerfeaturestoreruntime/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Used for data ingestion into the FeatureStore . The PutRecord API writes to
// both the OnlineStore and OfflineStore . If the record is the latest record for
// the recordIdentifier , the record is written to both the OnlineStore and
// OfflineStore . If the record is a historic record, it is written only to the
// OfflineStore .
func (c *Client) PutRecord(ctx context.Context, params *PutRecordInput, optFns ...func(*Options)) (*PutRecordOutput, error) {
if params == nil {
params = &PutRecordInput{}
}
result, metadata, err := c.invokeOperation(ctx, "PutRecord", params, optFns, c.addOperationPutRecordMiddlewares)
if err != nil {
return nil, err
}
out := result.(*PutRecordOutput)
out.ResultMetadata = metadata
return out, nil
}
type PutRecordInput struct {
// The name of the feature group that you want to insert the record into.
//
// This member is required.
FeatureGroupName *string
// List of FeatureValues to be inserted. This will be a full over-write. If you
// only want to update few of the feature values, do the following:
// - Use GetRecord to retrieve the latest record.
// - Update the record returned from GetRecord .
// - Use PutRecord to update feature values.
//
// This member is required.
Record []types.FeatureValue
// A list of stores to which you're adding the record. By default, Feature Store
// adds the record to all of the stores that you're using for the FeatureGroup .
TargetStores []types.TargetStore
// Time to live duration, where the record is hard deleted after the expiration
// time is reached; ExpiresAt = EventTime + TtlDuration . For information on
// HardDelete, see the DeleteRecord (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_feature_store_DeleteRecord.html)
// API in the Amazon SageMaker API Reference guide.
TtlDuration *types.TtlDuration
noSmithyDocumentSerde
}
type PutRecordOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationPutRecordMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpPutRecord{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpPutRecord{}, 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 = addOpPutRecordValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutRecord(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_opPutRecord(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "PutRecord",
}
}
| 144 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerfeaturestoreruntime
import (
"bytes"
"context"
"encoding/json"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
"github.com/aws/aws-sdk-go-v2/service/sagemakerfeaturestoreruntime/types"
smithy "github.com/aws/smithy-go"
smithyio "github.com/aws/smithy-go/io"
"github.com/aws/smithy-go/middleware"
"github.com/aws/smithy-go/ptr"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io"
"io/ioutil"
"strings"
)
type awsRestjson1_deserializeOpBatchGetRecord struct {
}
func (*awsRestjson1_deserializeOpBatchGetRecord) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpBatchGetRecord) 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_deserializeOpErrorBatchGetRecord(response, &metadata)
}
output := &BatchGetRecordOutput{}
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_deserializeOpDocumentBatchGetRecordOutput(&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_deserializeOpErrorBatchGetRecord(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("AccessForbidden", errorCode):
return awsRestjson1_deserializeErrorAccessForbidden(response, errorBody)
case strings.EqualFold("InternalFailure", errorCode):
return awsRestjson1_deserializeErrorInternalFailure(response, errorBody)
case strings.EqualFold("ServiceUnavailable", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailable(response, errorBody)
case strings.EqualFold("ValidationError", errorCode):
return awsRestjson1_deserializeErrorValidationError(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentBatchGetRecordOutput(v **BatchGetRecordOutput, 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 *BatchGetRecordOutput
if *v == nil {
sv = &BatchGetRecordOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Errors":
if err := awsRestjson1_deserializeDocumentBatchGetRecordErrors(&sv.Errors, value); err != nil {
return err
}
case "Records":
if err := awsRestjson1_deserializeDocumentBatchGetRecordResultDetails(&sv.Records, value); err != nil {
return err
}
case "UnprocessedIdentifiers":
if err := awsRestjson1_deserializeDocumentUnprocessedIdentifiers(&sv.UnprocessedIdentifiers, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDeleteRecord struct {
}
func (*awsRestjson1_deserializeOpDeleteRecord) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeleteRecord) 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_deserializeOpErrorDeleteRecord(response, &metadata)
}
output := &DeleteRecordOutput{}
out.Result = output
if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDeleteRecord(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("AccessForbidden", errorCode):
return awsRestjson1_deserializeErrorAccessForbidden(response, errorBody)
case strings.EqualFold("InternalFailure", errorCode):
return awsRestjson1_deserializeErrorInternalFailure(response, errorBody)
case strings.EqualFold("ServiceUnavailable", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailable(response, errorBody)
case strings.EqualFold("ValidationError", errorCode):
return awsRestjson1_deserializeErrorValidationError(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpGetRecord struct {
}
func (*awsRestjson1_deserializeOpGetRecord) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetRecord) 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_deserializeOpErrorGetRecord(response, &metadata)
}
output := &GetRecordOutput{}
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_deserializeOpDocumentGetRecordOutput(&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_deserializeOpErrorGetRecord(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("AccessForbidden", errorCode):
return awsRestjson1_deserializeErrorAccessForbidden(response, errorBody)
case strings.EqualFold("InternalFailure", errorCode):
return awsRestjson1_deserializeErrorInternalFailure(response, errorBody)
case strings.EqualFold("ResourceNotFound", errorCode):
return awsRestjson1_deserializeErrorResourceNotFound(response, errorBody)
case strings.EqualFold("ServiceUnavailable", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailable(response, errorBody)
case strings.EqualFold("ValidationError", errorCode):
return awsRestjson1_deserializeErrorValidationError(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetRecordOutput(v **GetRecordOutput, 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 *GetRecordOutput
if *v == nil {
sv = &GetRecordOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ExpiresAt":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ExpiresAt to be of type string, got %T instead", value)
}
sv.ExpiresAt = ptr.String(jtv)
}
case "Record":
if err := awsRestjson1_deserializeDocumentRecord(&sv.Record, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpPutRecord struct {
}
func (*awsRestjson1_deserializeOpPutRecord) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpPutRecord) 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_deserializeOpErrorPutRecord(response, &metadata)
}
output := &PutRecordOutput{}
out.Result = output
if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorPutRecord(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("AccessForbidden", errorCode):
return awsRestjson1_deserializeErrorAccessForbidden(response, errorBody)
case strings.EqualFold("InternalFailure", errorCode):
return awsRestjson1_deserializeErrorInternalFailure(response, errorBody)
case strings.EqualFold("ServiceUnavailable", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailable(response, errorBody)
case strings.EqualFold("ValidationError", errorCode):
return awsRestjson1_deserializeErrorValidationError(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeErrorAccessForbidden(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.AccessForbidden{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, 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 err
}
err := awsRestjson1_deserializeDocumentAccessForbidden(&output, shape)
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)
return output
}
func awsRestjson1_deserializeErrorInternalFailure(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.InternalFailure{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, 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 err
}
err := awsRestjson1_deserializeDocumentInternalFailure(&output, shape)
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)
return output
}
func awsRestjson1_deserializeErrorResourceNotFound(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ResourceNotFound{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, 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 err
}
err := awsRestjson1_deserializeDocumentResourceNotFound(&output, shape)
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)
return output
}
func awsRestjson1_deserializeErrorServiceUnavailable(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ServiceUnavailable{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, 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 err
}
err := awsRestjson1_deserializeDocumentServiceUnavailable(&output, shape)
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)
return output
}
func awsRestjson1_deserializeErrorValidationError(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ValidationError{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, 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 err
}
err := awsRestjson1_deserializeDocumentValidationError(&output, shape)
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)
return output
}
func awsRestjson1_deserializeDocumentAccessForbidden(v **types.AccessForbidden, 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.AccessForbidden
if *v == nil {
sv = &types.AccessForbidden{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Message to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentBatchGetRecordError(v **types.BatchGetRecordError, 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.BatchGetRecordError
if *v == nil {
sv = &types.BatchGetRecordError{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ErrorCode":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ValueAsString to be of type string, got %T instead", value)
}
sv.ErrorCode = ptr.String(jtv)
}
case "ErrorMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Message to be of type string, got %T instead", value)
}
sv.ErrorMessage = ptr.String(jtv)
}
case "FeatureGroupName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ValueAsString to be of type string, got %T instead", value)
}
sv.FeatureGroupName = ptr.String(jtv)
}
case "RecordIdentifierValueAsString":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ValueAsString to be of type string, got %T instead", value)
}
sv.RecordIdentifierValueAsString = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentBatchGetRecordErrors(v *[]types.BatchGetRecordError, 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.BatchGetRecordError
if *v == nil {
cv = []types.BatchGetRecordError{}
} else {
cv = *v
}
for _, value := range shape {
var col types.BatchGetRecordError
destAddr := &col
if err := awsRestjson1_deserializeDocumentBatchGetRecordError(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentBatchGetRecordIdentifier(v **types.BatchGetRecordIdentifier, 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.BatchGetRecordIdentifier
if *v == nil {
sv = &types.BatchGetRecordIdentifier{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "FeatureGroupName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FeatureGroupName to be of type string, got %T instead", value)
}
sv.FeatureGroupName = ptr.String(jtv)
}
case "FeatureNames":
if err := awsRestjson1_deserializeDocumentFeatureNames(&sv.FeatureNames, value); err != nil {
return err
}
case "RecordIdentifiersValueAsString":
if err := awsRestjson1_deserializeDocumentRecordIdentifiers(&sv.RecordIdentifiersValueAsString, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentBatchGetRecordResultDetail(v **types.BatchGetRecordResultDetail, 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.BatchGetRecordResultDetail
if *v == nil {
sv = &types.BatchGetRecordResultDetail{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ExpiresAt":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ExpiresAt to be of type string, got %T instead", value)
}
sv.ExpiresAt = ptr.String(jtv)
}
case "FeatureGroupName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ValueAsString to be of type string, got %T instead", value)
}
sv.FeatureGroupName = ptr.String(jtv)
}
case "Record":
if err := awsRestjson1_deserializeDocumentRecord(&sv.Record, value); err != nil {
return err
}
case "RecordIdentifierValueAsString":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ValueAsString to be of type string, got %T instead", value)
}
sv.RecordIdentifierValueAsString = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentBatchGetRecordResultDetails(v *[]types.BatchGetRecordResultDetail, 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.BatchGetRecordResultDetail
if *v == nil {
cv = []types.BatchGetRecordResultDetail{}
} else {
cv = *v
}
for _, value := range shape {
var col types.BatchGetRecordResultDetail
destAddr := &col
if err := awsRestjson1_deserializeDocumentBatchGetRecordResultDetail(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentFeatureNames(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 FeatureName to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentFeatureValue(v **types.FeatureValue, 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.FeatureValue
if *v == nil {
sv = &types.FeatureValue{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "FeatureName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FeatureName to be of type string, got %T instead", value)
}
sv.FeatureName = ptr.String(jtv)
}
case "ValueAsString":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ValueAsString to be of type string, got %T instead", value)
}
sv.ValueAsString = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentInternalFailure(v **types.InternalFailure, 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.InternalFailure
if *v == nil {
sv = &types.InternalFailure{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Message to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentRecord(v *[]types.FeatureValue, 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.FeatureValue
if *v == nil {
cv = []types.FeatureValue{}
} else {
cv = *v
}
for _, value := range shape {
var col types.FeatureValue
destAddr := &col
if err := awsRestjson1_deserializeDocumentFeatureValue(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentRecordIdentifiers(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 ValueAsString to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentResourceNotFound(v **types.ResourceNotFound, 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.ResourceNotFound
if *v == nil {
sv = &types.ResourceNotFound{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Message to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentServiceUnavailable(v **types.ServiceUnavailable, 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.ServiceUnavailable
if *v == nil {
sv = &types.ServiceUnavailable{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Message to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentUnprocessedIdentifiers(v *[]types.BatchGetRecordIdentifier, 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.BatchGetRecordIdentifier
if *v == nil {
cv = []types.BatchGetRecordIdentifier{}
} else {
cv = *v
}
for _, value := range shape {
var col types.BatchGetRecordIdentifier
destAddr := &col
if err := awsRestjson1_deserializeDocumentBatchGetRecordIdentifier(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentValidationError(v **types.ValidationError, 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.ValidationError
if *v == nil {
sv = &types.ValidationError{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Message to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
| 1,368 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package sagemakerfeaturestoreruntime provides the API client, operations, and
// parameter types for Amazon SageMaker Feature Store Runtime.
//
// Contains all data plane API operations and data types for the Amazon SageMaker
// Feature Store. Use this API to put, delete, and retrieve (get) features from a
// feature store. Use the following operations to configure your OnlineStore and
// OfflineStore features, and to create and manage feature groups:
// - CreateFeatureGroup (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateFeatureGroup.html)
// - DeleteFeatureGroup (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteFeatureGroup.html)
// - DescribeFeatureGroup (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeFeatureGroup.html)
// - ListFeatureGroups (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListFeatureGroups.html)
package sagemakerfeaturestoreruntime
| 15 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerfeaturestoreruntime
import (
"context"
"errors"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
internalendpoints "github.com/aws/aws-sdk-go-v2/service/sagemakerfeaturestoreruntime/internal/endpoints"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net/url"
"strings"
)
// EndpointResolverOptions is the service endpoint resolver options
type EndpointResolverOptions = internalendpoints.Options
// EndpointResolver interface for resolving service endpoints.
type EndpointResolver interface {
ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
}
var _ EndpointResolver = &internalendpoints.Resolver{}
// NewDefaultEndpointResolver constructs a new service endpoint resolver
func NewDefaultEndpointResolver() *internalendpoints.Resolver {
return internalendpoints.New()
}
// 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.
type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)
func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
return fn(region, options)
}
func resolveDefaultEndpointConfiguration(o *Options) {
if o.EndpointResolver != nil {
return
}
o.EndpointResolver = NewDefaultEndpointResolver()
}
// 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.
func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver {
e := aws.Endpoint{URL: url, Source: aws.EndpointSourceCustom}
for _, fn := range optFns {
fn(&e)
}
return EndpointResolverFunc(
func(region string, options EndpointResolverOptions) (aws.Endpoint, error) {
if len(e.SigningRegion) == 0 {
e.SigningRegion = region
}
return e, nil
},
)
}
type ResolveEndpoint struct {
Resolver EndpointResolver
Options EndpointResolverOptions
}
func (*ResolveEndpoint) ID() string {
return "ResolveEndpoint"
}
func (m *ResolveEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
if m.Resolver == nil {
return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
}
eo := m.Options
eo.Logger = middleware.GetLogger(ctx)
var endpoint aws.Endpoint
endpoint, err = m.Resolver.ResolveEndpoint(awsmiddleware.GetRegion(ctx), eo)
if err != nil {
return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err)
}
req.URL, err = url.Parse(endpoint.URL)
if err != nil {
return out, metadata, fmt.Errorf("failed to parse endpoint URL: %w", err)
}
if len(awsmiddleware.GetSigningName(ctx)) == 0 {
signingName := endpoint.SigningName
if len(signingName) == 0 {
signingName = "sagemaker"
}
ctx = awsmiddleware.SetSigningName(ctx, signingName)
}
ctx = awsmiddleware.SetEndpointSource(ctx, endpoint.Source)
ctx = smithyhttp.SetHostnameImmutable(ctx, endpoint.HostnameImmutable)
ctx = awsmiddleware.SetSigningRegion(ctx, endpoint.SigningRegion)
ctx = awsmiddleware.SetPartitionID(ctx, endpoint.PartitionID)
return next.HandleSerialize(ctx, in)
}
func addResolveEndpointMiddleware(stack *middleware.Stack, o Options) error {
return stack.Serialize.Insert(&ResolveEndpoint{
Resolver: o.EndpointResolver,
Options: o.EndpointOptions,
}, "OperationSerializer", middleware.Before)
}
func removeResolveEndpointMiddleware(stack *middleware.Stack) error {
_, err := stack.Serialize.Remove((&ResolveEndpoint{}).ID())
return err
}
type wrappedEndpointResolver struct {
awsResolver aws.EndpointResolverWithOptions
resolver EndpointResolver
}
func (w *wrappedEndpointResolver) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
if w.awsResolver == nil {
goto fallback
}
endpoint, err = w.awsResolver.ResolveEndpoint(ServiceID, region, options)
if err == nil {
return endpoint, nil
}
if nf := (&aws.EndpointNotFoundError{}); !errors.As(err, &nf) {
return endpoint, err
}
fallback:
if w.resolver == nil {
return endpoint, fmt.Errorf("default endpoint resolver provided was nil")
}
return w.resolver.ResolveEndpoint(region, options)
}
type awsEndpointResolverAdaptor func(service, region string) (aws.Endpoint, error)
func (a awsEndpointResolverAdaptor) ResolveEndpoint(service, region string, options ...interface{}) (aws.Endpoint, error) {
return a(service, region)
}
var _ aws.EndpointResolverWithOptions = awsEndpointResolverAdaptor(nil)
// withEndpointResolver returns an EndpointResolver that first delegates endpoint resolution to the awsResolver.
// If awsResolver returns aws.EndpointNotFoundError error, the resolver will use the the provided
// fallbackResolver for resolution.
//
// fallbackResolver must not be nil
func withEndpointResolver(awsResolver aws.EndpointResolver, awsResolverWithOptions aws.EndpointResolverWithOptions, fallbackResolver EndpointResolver) EndpointResolver {
var resolver aws.EndpointResolverWithOptions
if awsResolverWithOptions != nil {
resolver = awsResolverWithOptions
} else if awsResolver != nil {
resolver = awsEndpointResolverAdaptor(awsResolver.ResolveEndpoint)
}
return &wrappedEndpointResolver{
awsResolver: resolver,
resolver: fallbackResolver,
}
}
func finalizeClientEndpointResolverOptions(options *Options) {
options.EndpointOptions.LogDeprecated = options.ClientLogMode.IsDeprecatedUsage()
if len(options.EndpointOptions.ResolvedRegion) == 0 {
const fipsInfix = "-fips-"
const fipsPrefix = "fips-"
const fipsSuffix = "-fips"
if strings.Contains(options.Region, fipsInfix) ||
strings.Contains(options.Region, fipsPrefix) ||
strings.Contains(options.Region, fipsSuffix) {
options.EndpointOptions.ResolvedRegion = strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(
options.Region, fipsInfix, "-"), fipsPrefix, ""), fipsSuffix, "")
options.EndpointOptions.UseFIPSEndpoint = aws.FIPSEndpointStateEnabled
}
}
}
| 201 |
aws-sdk-go-v2 | aws | Go | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT.
package sagemakerfeaturestoreruntime
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.15.0"
| 7 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerfeaturestoreruntime
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerfeaturestoreruntime
import (
"bytes"
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/sagemakerfeaturestoreruntime/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/encoding/httpbinding"
smithyjson "github.com/aws/smithy-go/encoding/json"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
type awsRestjson1_serializeOpBatchGetRecord struct {
}
func (*awsRestjson1_serializeOpBatchGetRecord) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpBatchGetRecord) 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.(*BatchGetRecordInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/BatchGetRecord")
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_serializeOpDocumentBatchGetRecordInput(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_serializeOpHttpBindingsBatchGetRecordInput(v *BatchGetRecordInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentBatchGetRecordInput(v *BatchGetRecordInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.ExpirationTimeResponse) > 0 {
ok := object.Key("ExpirationTimeResponse")
ok.String(string(v.ExpirationTimeResponse))
}
if v.Identifiers != nil {
ok := object.Key("Identifiers")
if err := awsRestjson1_serializeDocumentBatchGetRecordIdentifiers(v.Identifiers, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteRecord struct {
}
func (*awsRestjson1_serializeOpDeleteRecord) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteRecord) 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.(*DeleteRecordInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/FeatureGroup/{FeatureGroupName}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsDeleteRecordInput(input, restEncoder); 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_serializeOpHttpBindingsDeleteRecordInput(v *DeleteRecordInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if len(v.DeletionMode) > 0 {
encoder.SetQuery("DeletionMode").String(string(v.DeletionMode))
}
if v.EventTime != nil {
encoder.SetQuery("EventTime").String(*v.EventTime)
}
if v.FeatureGroupName == nil || len(*v.FeatureGroupName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member FeatureGroupName must not be empty")}
}
if v.FeatureGroupName != nil {
if err := encoder.SetURI("FeatureGroupName").String(*v.FeatureGroupName); err != nil {
return err
}
}
if v.RecordIdentifierValueAsString != nil {
encoder.SetQuery("RecordIdentifierValueAsString").String(*v.RecordIdentifierValueAsString)
}
if v.TargetStores != nil {
for i := range v.TargetStores {
encoder.AddQuery("TargetStores").String(string(v.TargetStores[i]))
}
}
return nil
}
type awsRestjson1_serializeOpGetRecord struct {
}
func (*awsRestjson1_serializeOpGetRecord) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetRecord) 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.(*GetRecordInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/FeatureGroup/{FeatureGroupName}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetRecordInput(input, restEncoder); 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_serializeOpHttpBindingsGetRecordInput(v *GetRecordInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if len(v.ExpirationTimeResponse) > 0 {
encoder.SetQuery("ExpirationTimeResponse").String(string(v.ExpirationTimeResponse))
}
if v.FeatureGroupName == nil || len(*v.FeatureGroupName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member FeatureGroupName must not be empty")}
}
if v.FeatureGroupName != nil {
if err := encoder.SetURI("FeatureGroupName").String(*v.FeatureGroupName); err != nil {
return err
}
}
if v.FeatureNames != nil {
for i := range v.FeatureNames {
encoder.AddQuery("FeatureName").String(v.FeatureNames[i])
}
}
if v.RecordIdentifierValueAsString != nil {
encoder.SetQuery("RecordIdentifierValueAsString").String(*v.RecordIdentifierValueAsString)
}
return nil
}
type awsRestjson1_serializeOpPutRecord struct {
}
func (*awsRestjson1_serializeOpPutRecord) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpPutRecord) 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.(*PutRecordInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/FeatureGroup/{FeatureGroupName}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PUT"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsPutRecordInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentPutRecordInput(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_serializeOpHttpBindingsPutRecordInput(v *PutRecordInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.FeatureGroupName == nil || len(*v.FeatureGroupName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member FeatureGroupName must not be empty")}
}
if v.FeatureGroupName != nil {
if err := encoder.SetURI("FeatureGroupName").String(*v.FeatureGroupName); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentPutRecordInput(v *PutRecordInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Record != nil {
ok := object.Key("Record")
if err := awsRestjson1_serializeDocumentRecord(v.Record, ok); err != nil {
return err
}
}
if v.TargetStores != nil {
ok := object.Key("TargetStores")
if err := awsRestjson1_serializeDocumentTargetStores(v.TargetStores, ok); err != nil {
return err
}
}
if v.TtlDuration != nil {
ok := object.Key("TtlDuration")
if err := awsRestjson1_serializeDocumentTtlDuration(v.TtlDuration, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentBatchGetRecordIdentifier(v *types.BatchGetRecordIdentifier, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FeatureGroupName != nil {
ok := object.Key("FeatureGroupName")
ok.String(*v.FeatureGroupName)
}
if v.FeatureNames != nil {
ok := object.Key("FeatureNames")
if err := awsRestjson1_serializeDocumentFeatureNames(v.FeatureNames, ok); err != nil {
return err
}
}
if v.RecordIdentifiersValueAsString != nil {
ok := object.Key("RecordIdentifiersValueAsString")
if err := awsRestjson1_serializeDocumentRecordIdentifiers(v.RecordIdentifiersValueAsString, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentBatchGetRecordIdentifiers(v []types.BatchGetRecordIdentifier, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentBatchGetRecordIdentifier(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentFeatureNames(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_serializeDocumentFeatureValue(v *types.FeatureValue, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FeatureName != nil {
ok := object.Key("FeatureName")
ok.String(*v.FeatureName)
}
if v.ValueAsString != nil {
ok := object.Key("ValueAsString")
ok.String(*v.ValueAsString)
}
return nil
}
func awsRestjson1_serializeDocumentRecord(v []types.FeatureValue, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentFeatureValue(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentRecordIdentifiers(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_serializeDocumentTargetStores(v []types.TargetStore, 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 awsRestjson1_serializeDocumentTtlDuration(v *types.TtlDuration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Unit) > 0 {
ok := object.Key("Unit")
ok.String(string(v.Unit))
}
if v.Value != nil {
ok := object.Key("Value")
ok.Integer(*v.Value)
}
return nil
}
| 455 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerfeaturestoreruntime
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/sagemakerfeaturestoreruntime/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpBatchGetRecord struct {
}
func (*validateOpBatchGetRecord) ID() string {
return "OperationInputValidation"
}
func (m *validateOpBatchGetRecord) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*BatchGetRecordInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpBatchGetRecordInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteRecord struct {
}
func (*validateOpDeleteRecord) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteRecord) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteRecordInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteRecordInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetRecord struct {
}
func (*validateOpGetRecord) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetRecord) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetRecordInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetRecordInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpPutRecord struct {
}
func (*validateOpPutRecord) ID() string {
return "OperationInputValidation"
}
func (m *validateOpPutRecord) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*PutRecordInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpPutRecordInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpBatchGetRecordValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpBatchGetRecord{}, middleware.After)
}
func addOpDeleteRecordValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteRecord{}, middleware.After)
}
func addOpGetRecordValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetRecord{}, middleware.After)
}
func addOpPutRecordValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpPutRecord{}, middleware.After)
}
func validateBatchGetRecordIdentifier(v *types.BatchGetRecordIdentifier) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchGetRecordIdentifier"}
if v.FeatureGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("FeatureGroupName"))
}
if v.RecordIdentifiersValueAsString == nil {
invalidParams.Add(smithy.NewErrParamRequired("RecordIdentifiersValueAsString"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateBatchGetRecordIdentifiers(v []types.BatchGetRecordIdentifier) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchGetRecordIdentifiers"}
for i := range v {
if err := validateBatchGetRecordIdentifier(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateFeatureValue(v *types.FeatureValue) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "FeatureValue"}
if v.FeatureName == nil {
invalidParams.Add(smithy.NewErrParamRequired("FeatureName"))
}
if v.ValueAsString == nil {
invalidParams.Add(smithy.NewErrParamRequired("ValueAsString"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateRecord(v []types.FeatureValue) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Record"}
for i := range v {
if err := validateFeatureValue(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTtlDuration(v *types.TtlDuration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TtlDuration"}
if len(v.Unit) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Unit"))
}
if v.Value == nil {
invalidParams.Add(smithy.NewErrParamRequired("Value"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpBatchGetRecordInput(v *BatchGetRecordInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchGetRecordInput"}
if v.Identifiers == nil {
invalidParams.Add(smithy.NewErrParamRequired("Identifiers"))
} else if v.Identifiers != nil {
if err := validateBatchGetRecordIdentifiers(v.Identifiers); err != nil {
invalidParams.AddNested("Identifiers", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteRecordInput(v *DeleteRecordInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteRecordInput"}
if v.FeatureGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("FeatureGroupName"))
}
if v.RecordIdentifierValueAsString == nil {
invalidParams.Add(smithy.NewErrParamRequired("RecordIdentifierValueAsString"))
}
if v.EventTime == nil {
invalidParams.Add(smithy.NewErrParamRequired("EventTime"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetRecordInput(v *GetRecordInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetRecordInput"}
if v.FeatureGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("FeatureGroupName"))
}
if v.RecordIdentifierValueAsString == nil {
invalidParams.Add(smithy.NewErrParamRequired("RecordIdentifierValueAsString"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpPutRecordInput(v *PutRecordInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PutRecordInput"}
if v.FeatureGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("FeatureGroupName"))
}
if v.Record == nil {
invalidParams.Add(smithy.NewErrParamRequired("Record"))
} else if v.Record != nil {
if err := validateRecord(v.Record); err != nil {
invalidParams.AddNested("Record", err.(smithy.InvalidParamsError))
}
}
if v.TtlDuration != nil {
if err := validateTtlDuration(v.TtlDuration); err != nil {
invalidParams.AddNested("TtlDuration", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 281 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"github.com/aws/aws-sdk-go-v2/aws"
endpoints "github.com/aws/aws-sdk-go-v2/internal/endpoints/v2"
"github.com/aws/smithy-go/logging"
"regexp"
)
// Options is the endpoint resolver configuration options
type Options struct {
// Logger is a logging implementation that log events should be sent to.
Logger logging.Logger
// LogDeprecated indicates that deprecated endpoints should be logged to the
// provided logger.
LogDeprecated bool
// ResolvedRegion is used to override the region to be resolved, rather then the
// using the value passed to the ResolveEndpoint method. This value is used by the
// SDK to translate regions like fips-us-east-1 or us-east-1-fips to an alternative
// name. You must not set this value directly in your application.
ResolvedRegion string
// DisableHTTPS informs the resolver to return an endpoint that does not use the
// HTTPS scheme.
DisableHTTPS bool
// UseDualStackEndpoint specifies the resolver must resolve a dual-stack endpoint.
UseDualStackEndpoint aws.DualStackEndpointState
// UseFIPSEndpoint specifies the resolver must resolve a FIPS endpoint.
UseFIPSEndpoint aws.FIPSEndpointState
}
func (o Options) GetResolvedRegion() string {
return o.ResolvedRegion
}
func (o Options) GetDisableHTTPS() bool {
return o.DisableHTTPS
}
func (o Options) GetUseDualStackEndpoint() aws.DualStackEndpointState {
return o.UseDualStackEndpoint
}
func (o Options) GetUseFIPSEndpoint() aws.FIPSEndpointState {
return o.UseFIPSEndpoint
}
func transformToSharedOptions(options Options) endpoints.Options {
return endpoints.Options{
Logger: options.Logger,
LogDeprecated: options.LogDeprecated,
ResolvedRegion: options.ResolvedRegion,
DisableHTTPS: options.DisableHTTPS,
UseDualStackEndpoint: options.UseDualStackEndpoint,
UseFIPSEndpoint: options.UseFIPSEndpoint,
}
}
// Resolver SageMaker FeatureStore Runtime endpoint resolver
type Resolver struct {
partitions endpoints.Partitions
}
// ResolveEndpoint resolves the service endpoint for the given region and options
func (r *Resolver) ResolveEndpoint(region string, options Options) (endpoint aws.Endpoint, err error) {
if len(region) == 0 {
return endpoint, &aws.MissingRegionError{}
}
opt := transformToSharedOptions(options)
return r.partitions.ResolveEndpoint(region, opt)
}
// New returns a new Resolver
func New() *Resolver {
return &Resolver{
partitions: defaultPartitions,
}
}
var partitionRegexp = struct {
Aws *regexp.Regexp
AwsCn *regexp.Regexp
AwsIso *regexp.Regexp
AwsIsoB *regexp.Regexp
AwsIsoE *regexp.Regexp
AwsIsoF *regexp.Regexp
AwsUsGov *regexp.Regexp
}{
Aws: regexp.MustCompile("^(us|eu|ap|sa|ca|me|af)\\-\\w+\\-\\d+$"),
AwsCn: regexp.MustCompile("^cn\\-\\w+\\-\\d+$"),
AwsIso: regexp.MustCompile("^us\\-iso\\-\\w+\\-\\d+$"),
AwsIsoB: regexp.MustCompile("^us\\-isob\\-\\w+\\-\\d+$"),
AwsIsoE: regexp.MustCompile("^eu\\-isoe\\-\\w+\\-\\d+$"),
AwsIsoF: regexp.MustCompile("^us\\-isof\\-\\w+\\-\\d+$"),
AwsUsGov: regexp.MustCompile("^us\\-gov\\-\\w+\\-\\d+$"),
}
var defaultPartitions = endpoints.Partitions{
{
ID: "aws",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "featurestore-runtime.sagemaker.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "featurestore-runtime.sagemaker-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "featurestore-runtime.sagemaker-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "featurestore-runtime.sagemaker.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.Aws,
IsRegionalized: true,
},
{
ID: "aws-cn",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "featurestore-runtime.sagemaker.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "featurestore-runtime.sagemaker-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "featurestore-runtime.sagemaker-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "featurestore-runtime.sagemaker.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsCn,
IsRegionalized: true,
},
{
ID: "aws-iso",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "featurestore-runtime.sagemaker-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "featurestore-runtime.sagemaker.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIso,
IsRegionalized: true,
},
{
ID: "aws-iso-b",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "featurestore-runtime.sagemaker-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "featurestore-runtime.sagemaker.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoB,
IsRegionalized: true,
},
{
ID: "aws-iso-e",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "featurestore-runtime.sagemaker-fips.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "featurestore-runtime.sagemaker.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoE,
IsRegionalized: true,
},
{
ID: "aws-iso-f",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "featurestore-runtime.sagemaker-fips.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "featurestore-runtime.sagemaker.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoF,
IsRegionalized: true,
},
{
ID: "aws-us-gov",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "featurestore-runtime.sagemaker.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "featurestore-runtime.sagemaker-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "featurestore-runtime.sagemaker-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "featurestore-runtime.sagemaker.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: true,
},
}
| 297 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"testing"
)
func TestRegexCompile(t *testing.T) {
_ = defaultPartitions
}
| 12 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
type DeletionMode string
// Enum values for DeletionMode
const (
DeletionModeSoftDelete DeletionMode = "SoftDelete"
DeletionModeHardDelete DeletionMode = "HardDelete"
)
// Values returns all known values for DeletionMode. 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 (DeletionMode) Values() []DeletionMode {
return []DeletionMode{
"SoftDelete",
"HardDelete",
}
}
type ExpirationTimeResponse string
// Enum values for ExpirationTimeResponse
const (
ExpirationTimeResponseEnabled ExpirationTimeResponse = "Enabled"
ExpirationTimeResponseDisabled ExpirationTimeResponse = "Disabled"
)
// Values returns all known values for ExpirationTimeResponse. 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 (ExpirationTimeResponse) Values() []ExpirationTimeResponse {
return []ExpirationTimeResponse{
"Enabled",
"Disabled",
}
}
type TargetStore string
// Enum values for TargetStore
const (
TargetStoreOnlineStore TargetStore = "OnlineStore"
TargetStoreOfflineStore TargetStore = "OfflineStore"
)
// Values returns all known values for TargetStore. 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 (TargetStore) Values() []TargetStore {
return []TargetStore{
"OnlineStore",
"OfflineStore",
}
}
type TtlDurationUnit string
// Enum values for TtlDurationUnit
const (
TtlDurationUnitSeconds TtlDurationUnit = "Seconds"
TtlDurationUnitMinutes TtlDurationUnit = "Minutes"
TtlDurationUnitHours TtlDurationUnit = "Hours"
TtlDurationUnitDays TtlDurationUnit = "Days"
TtlDurationUnitWeeks TtlDurationUnit = "Weeks"
)
// Values returns all known values for TtlDurationUnit. 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 (TtlDurationUnit) Values() []TtlDurationUnit {
return []TtlDurationUnit{
"Seconds",
"Minutes",
"Hours",
"Days",
"Weeks",
}
}
| 82 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
"fmt"
smithy "github.com/aws/smithy-go"
)
// You do not have permission to perform an action.
type AccessForbidden struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *AccessForbidden) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *AccessForbidden) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *AccessForbidden) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "AccessForbidden"
}
return *e.ErrorCodeOverride
}
func (e *AccessForbidden) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// An internal failure occurred. Try your request again. If the problem persists,
// contact Amazon Web Services customer support.
type InternalFailure struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InternalFailure) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InternalFailure) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InternalFailure) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InternalFailure"
}
return *e.ErrorCodeOverride
}
func (e *InternalFailure) ErrorFault() smithy.ErrorFault { return smithy.FaultServer }
// A resource that is required to perform an action was not found.
type ResourceNotFound struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ResourceNotFound) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ResourceNotFound) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ResourceNotFound) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ResourceNotFound"
}
return *e.ErrorCodeOverride
}
func (e *ResourceNotFound) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The service is currently unavailable.
type ServiceUnavailable struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ServiceUnavailable) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ServiceUnavailable) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ServiceUnavailable) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ServiceUnavailable"
}
return *e.ErrorCodeOverride
}
func (e *ServiceUnavailable) ErrorFault() smithy.ErrorFault { return smithy.FaultServer }
// There was an error validating your request.
type ValidationError struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ValidationError) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ValidationError) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ValidationError) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ValidationError"
}
return *e.ErrorCodeOverride
}
func (e *ValidationError) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
| 140 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
smithydocument "github.com/aws/smithy-go/document"
)
// The error that has occurred when attempting to retrieve a batch of Records.
type BatchGetRecordError struct {
// The error code of an error that has occurred when attempting to retrieve a
// batch of Records. For more information on errors, see Errors (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_feature_store_GetRecord.html#API_feature_store_GetRecord_Errors)
// .
//
// This member is required.
ErrorCode *string
// The error message of an error that has occurred when attempting to retrieve a
// record in the batch.
//
// This member is required.
ErrorMessage *string
// The name of the feature group that the record belongs to.
//
// This member is required.
FeatureGroupName *string
// The value for the RecordIdentifier in string format of a Record from a
// FeatureGroup that is causing an error when attempting to be retrieved.
//
// This member is required.
RecordIdentifierValueAsString *string
noSmithyDocumentSerde
}
// The identifier that identifies the batch of Records you are retrieving in a
// batch.
type BatchGetRecordIdentifier struct {
// A FeatureGroupName containing Records you are retrieving in a batch.
//
// This member is required.
FeatureGroupName *string
// The value for a list of record identifiers in string format.
//
// This member is required.
RecordIdentifiersValueAsString []string
// List of names of Features to be retrieved. If not specified, the latest value
// for all the Features are returned.
FeatureNames []string
noSmithyDocumentSerde
}
// The output of Records that have been retrieved in a batch.
type BatchGetRecordResultDetail struct {
// The FeatureGroupName containing Records you retrieved in a batch.
//
// This member is required.
FeatureGroupName *string
// The Record retrieved.
//
// This member is required.
Record []FeatureValue
// The value of the record identifier in string format.
//
// This member is required.
RecordIdentifierValueAsString *string
// The ExpiresAt ISO string of the requested record.
ExpiresAt *string
noSmithyDocumentSerde
}
// The value associated with a feature.
type FeatureValue struct {
// The name of a feature that a feature value corresponds to.
//
// This member is required.
FeatureName *string
// The value associated with a feature, in string format. Note that features types
// can be String, Integral, or Fractional. This value represents all three types as
// a string.
//
// This member is required.
ValueAsString *string
noSmithyDocumentSerde
}
// Time to live duration, where the record is hard deleted after the expiration
// time is reached; ExpiresAt = EventTime + TtlDuration . For information on
// HardDelete, see the DeleteRecord (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_feature_store_DeleteRecord.html)
// API in the Amazon SageMaker API Reference guide.
type TtlDuration struct {
// TtlDuration time unit.
//
// This member is required.
Unit TtlDurationUnit
// TtlDuration time value.
//
// This member is required.
Value *int32
noSmithyDocumentSerde
}
type noSmithyDocumentSerde = smithydocument.NoSerde
| 122 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
import (
"context"
cryptorand "crypto/rand"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/aws/defaults"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/retry"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources"
smithy "github.com/aws/smithy-go"
smithydocument "github.com/aws/smithy-go/document"
"github.com/aws/smithy-go/logging"
"github.com/aws/smithy-go/middleware"
smithyrand "github.com/aws/smithy-go/rand"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net"
"net/http"
"time"
)
const ServiceID = "SageMaker Geospatial"
const ServiceAPIVersion = "2020-05-27"
// Client provides the API client to make operations call for Amazon SageMaker
// geospatial capabilities.
type Client struct {
options Options
}
// 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 New(options Options, optFns ...func(*Options)) *Client {
options = options.Copy()
resolveDefaultLogger(&options)
setResolvedDefaultsMode(&options)
resolveRetryer(&options)
resolveHTTPClient(&options)
resolveHTTPSignerV4(&options)
resolveDefaultEndpointConfiguration(&options)
resolveIdempotencyTokenProvider(&options)
for _, fn := range optFns {
fn(&options)
}
client := &Client{
options: options,
}
return client
}
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 configuration DefaultsMode that the SDK should use when constructing the
// clients initial default settings.
DefaultsMode aws.DefaultsMode
// 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
// Provides idempotency tokens values that will be automatically populated into
// idempotent API operations.
IdempotencyTokenProvider IdempotencyTokenProvider
// The logger writer interface to write logging messages to.
Logger logging.Logger
// The region to send requests to. (Required)
Region string
// RetryMaxAttempts specifies the maximum number attempts an API client will call
// an operation that fails with a retryable error. A value of 0 is ignored, and
// will not be used to configure the API client created default retryer, or modify
// per operation call's retry max attempts. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. If specified in an operation call's functional
// options with a value that is different than the constructed client's Options,
// the Client's Retryer will be wrapped to use the operation's specific
// RetryMaxAttempts value.
RetryMaxAttempts int
// RetryMode specifies the retry mode the API client will be created with, if
// Retryer option is not also specified. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. Currently does not support per operation call
// overrides, may in the future.
RetryMode aws.RetryMode
// Retryer guides how HTTP requests should be retried in case of recoverable
// failures. When nil the API client will use a default retryer. The kind of
// default retry created by the API client can be changed with the RetryMode
// option.
Retryer aws.Retryer
// The RuntimeEnvironment configuration, only populated if the DefaultsMode is set
// to DefaultsModeAuto and is initialized using config.LoadDefaultConfig . You
// should not populate this structure programmatically, or rely on the values here
// within your applications.
RuntimeEnvironment aws.RuntimeEnvironment
// The initial DefaultsMode used when the client options were constructed. If the
// DefaultsMode was set to aws.DefaultsModeAuto this will store what the resolved
// value was at that point in time. Currently does not support per operation call
// overrides, may in the future.
resolvedDefaultsMode aws.DefaultsMode
// The HTTP client to invoke API calls with. Defaults to client's default HTTP
// implementation if nil.
HTTPClient HTTPClient
}
// WithAPIOptions returns a functional option for setting the Client's APIOptions
// option.
func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options) {
return func(o *Options) {
o.APIOptions = append(o.APIOptions, optFns...)
}
}
// WithEndpointResolver returns a functional option for setting the Client's
// EndpointResolver option.
func WithEndpointResolver(v EndpointResolver) func(*Options) {
return func(o *Options) {
o.EndpointResolver = v
}
}
type HTTPClient interface {
Do(*http.Request) (*http.Response, error)
}
// Copy creates a clone where the APIOptions list is deep copied.
func (o Options) Copy() Options {
to := o
to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions))
copy(to.APIOptions, o.APIOptions)
return to
}
func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) {
ctx = middleware.ClearStackValues(ctx)
stack := middleware.NewStack(opID, smithyhttp.NewStackRequest)
options := c.options.Copy()
for _, fn := range optFns {
fn(&options)
}
finalizeRetryMaxAttemptOptions(&options, *c)
finalizeClientEndpointResolverOptions(&options)
for _, fn := range stackFns {
if err := fn(stack, options); err != nil {
return nil, metadata, err
}
}
for _, fn := range options.APIOptions {
if err := fn(stack); err != nil {
return nil, metadata, err
}
}
handler := middleware.DecorateHandler(smithyhttp.NewClientHandler(options.HTTPClient), stack)
result, metadata, err = handler.Handle(ctx, params)
if err != nil {
err = &smithy.OperationError{
ServiceID: ServiceID,
OperationName: opID,
Err: err,
}
}
return result, metadata, err
}
type noSmithyDocumentSerde = smithydocument.NoSerde
func resolveDefaultLogger(o *Options) {
if o.Logger != nil {
return
}
o.Logger = logging.Nop{}
}
func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error {
return middleware.AddSetLoggerMiddleware(stack, o.Logger)
}
func setResolvedDefaultsMode(o *Options) {
if len(o.resolvedDefaultsMode) > 0 {
return
}
var mode aws.DefaultsMode
mode.SetFromString(string(o.DefaultsMode))
if mode == aws.DefaultsModeAuto {
mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment)
}
o.resolvedDefaultsMode = mode
}
// NewFromConfig returns a new client from the provided config.
func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client {
opts := Options{
Region: cfg.Region,
DefaultsMode: cfg.DefaultsMode,
RuntimeEnvironment: cfg.RuntimeEnvironment,
HTTPClient: cfg.HTTPClient,
Credentials: cfg.Credentials,
APIOptions: cfg.APIOptions,
Logger: cfg.Logger,
ClientLogMode: cfg.ClientLogMode,
}
resolveAWSRetryerProvider(cfg, &opts)
resolveAWSRetryMaxAttempts(cfg, &opts)
resolveAWSRetryMode(cfg, &opts)
resolveAWSEndpointResolver(cfg, &opts)
resolveUseDualStackEndpoint(cfg, &opts)
resolveUseFIPSEndpoint(cfg, &opts)
return New(opts, optFns...)
}
func resolveHTTPClient(o *Options) {
var buildable *awshttp.BuildableClient
if o.HTTPClient != nil {
var ok bool
buildable, ok = o.HTTPClient.(*awshttp.BuildableClient)
if !ok {
return
}
} else {
buildable = awshttp.NewBuildableClient()
}
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) {
if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok {
dialer.Timeout = dialerTimeout
}
})
buildable = buildable.WithTransportOptions(func(transport *http.Transport) {
if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok {
transport.TLSHandshakeTimeout = tlsHandshakeTimeout
}
})
}
o.HTTPClient = buildable
}
func resolveRetryer(o *Options) {
if o.Retryer != nil {
return
}
if len(o.RetryMode) == 0 {
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
o.RetryMode = modeConfig.RetryMode
}
}
if len(o.RetryMode) == 0 {
o.RetryMode = aws.RetryModeStandard
}
var standardOptions []func(*retry.StandardOptions)
if v := o.RetryMaxAttempts; v != 0 {
standardOptions = append(standardOptions, func(so *retry.StandardOptions) {
so.MaxAttempts = v
})
}
switch o.RetryMode {
case aws.RetryModeAdaptive:
var adaptiveOptions []func(*retry.AdaptiveModeOptions)
if len(standardOptions) != 0 {
adaptiveOptions = append(adaptiveOptions, func(ao *retry.AdaptiveModeOptions) {
ao.StandardOptions = append(ao.StandardOptions, standardOptions...)
})
}
o.Retryer = retry.NewAdaptiveMode(adaptiveOptions...)
default:
o.Retryer = retry.NewStandard(standardOptions...)
}
}
func resolveAWSRetryerProvider(cfg aws.Config, o *Options) {
if cfg.Retryer == nil {
return
}
o.Retryer = cfg.Retryer()
}
func resolveAWSRetryMode(cfg aws.Config, o *Options) {
if len(cfg.RetryMode) == 0 {
return
}
o.RetryMode = cfg.RetryMode
}
func resolveAWSRetryMaxAttempts(cfg aws.Config, o *Options) {
if cfg.RetryMaxAttempts == 0 {
return
}
o.RetryMaxAttempts = cfg.RetryMaxAttempts
}
func finalizeRetryMaxAttemptOptions(o *Options, client Client) {
if v := o.RetryMaxAttempts; v == 0 || v == client.options.RetryMaxAttempts {
return
}
o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts)
}
func resolveAWSEndpointResolver(cfg aws.Config, o *Options) {
if cfg.EndpointResolver == nil && cfg.EndpointResolverWithOptions == nil {
return
}
o.EndpointResolver = withEndpointResolver(cfg.EndpointResolver, cfg.EndpointResolverWithOptions, NewDefaultEndpointResolver())
}
func addClientUserAgent(stack *middleware.Stack) error {
return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "sagemakergeospatial", goModuleVersion)(stack)
}
func addHTTPSignerV4Middleware(stack *middleware.Stack, o Options) error {
mw := v4.NewSignHTTPRequestMiddleware(v4.SignHTTPRequestMiddlewareOptions{
CredentialsProvider: o.Credentials,
Signer: o.HTTPSignerV4,
LogSigning: o.ClientLogMode.IsSigning(),
})
return stack.Finalize.Add(mw, middleware.After)
}
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
}
func resolveHTTPSignerV4(o *Options) {
if o.HTTPSignerV4 != nil {
return
}
o.HTTPSignerV4 = newDefaultV4Signer(*o)
}
func newDefaultV4Signer(o Options) *v4.Signer {
return v4.NewSigner(func(so *v4.SignerOptions) {
so.Logger = o.Logger
so.LogSigning = o.ClientLogMode.IsSigning()
})
}
func resolveIdempotencyTokenProvider(o *Options) {
if o.IdempotencyTokenProvider != nil {
return
}
o.IdempotencyTokenProvider = smithyrand.NewUUIDIdempotencyToken(cryptorand.Reader)
}
func addRetryMiddlewares(stack *middleware.Stack, o Options) error {
mo := retry.AddRetryMiddlewaresOptions{
Retryer: o.Retryer,
LogRetryAttempts: o.ClientLogMode.IsRetries(),
}
return retry.AddRetryMiddlewares(stack, mo)
}
// resolves dual-stack endpoint configuration
func resolveUseDualStackEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseDualStackEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseDualStackEndpoint = value
}
return nil
}
// resolves FIPS endpoint configuration
func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseFIPSEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseFIPSEndpoint = value
}
return nil
}
// IdempotencyTokenProvider interface for providing idempotency token
type IdempotencyTokenProvider interface {
GetIdempotencyToken() (string, error)
}
func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error {
return awsmiddleware.AddRequestIDRetrieverMiddleware(stack)
}
func addResponseErrorMiddleware(stack *middleware.Stack) error {
return awshttp.AddResponseErrorMiddleware(stack)
}
func addRequestResponseLogging(stack *middleware.Stack, o Options) error {
return stack.Deserialize.Add(&smithyhttp.RequestResponseLogger{
LogRequest: o.ClientLogMode.IsRequest(),
LogRequestWithBody: o.ClientLogMode.IsRequestWithBody(),
LogResponse: o.ClientLogMode.IsResponse(),
LogResponseWithBody: o.ClientLogMode.IsResponseWithBody(),
}, middleware.After)
}
| 455 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io/ioutil"
"net/http"
"strings"
"testing"
)
func TestClient_resolveRetryOptions(t *testing.T) {
nopClient := smithyhttp.ClientDoFunc(func(_ *http.Request) (*http.Response, error) {
return &http.Response{
StatusCode: 200,
Header: http.Header{},
Body: ioutil.NopCloser(strings.NewReader("")),
}, nil
})
cases := map[string]struct {
defaultsMode aws.DefaultsMode
retryer aws.Retryer
retryMaxAttempts int
opRetryMaxAttempts *int
retryMode aws.RetryMode
expectClientRetryMode aws.RetryMode
expectClientMaxAttempts int
expectOpMaxAttempts int
}{
"defaults": {
defaultsMode: aws.DefaultsModeStandard,
expectClientRetryMode: aws.RetryModeStandard,
expectClientMaxAttempts: 3,
expectOpMaxAttempts: 3,
},
"custom default retry": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(2),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 2,
},
"custom op no change max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(10),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op 0 max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(0),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
client := NewFromConfig(aws.Config{
DefaultsMode: c.defaultsMode,
Retryer: func() func() aws.Retryer {
if c.retryer == nil {
return nil
}
return func() aws.Retryer { return c.retryer }
}(),
HTTPClient: nopClient,
RetryMaxAttempts: c.retryMaxAttempts,
RetryMode: c.retryMode,
})
if e, a := c.expectClientRetryMode, client.options.RetryMode; e != a {
t.Errorf("expect %v retry mode, got %v", e, a)
}
if e, a := c.expectClientMaxAttempts, client.options.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v max attempts, got %v", e, a)
}
_, _, err := client.invokeOperation(context.Background(), "mockOperation", struct{}{},
[]func(*Options){
func(o *Options) {
if c.opRetryMaxAttempts == nil {
return
}
o.RetryMaxAttempts = *c.opRetryMaxAttempts
},
},
func(s *middleware.Stack, o Options) error {
s.Initialize.Clear()
s.Serialize.Clear()
s.Build.Clear()
s.Finalize.Clear()
s.Deserialize.Clear()
if e, a := c.expectOpMaxAttempts, o.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v op max attempts, got %v", e, a)
}
return nil
})
if err != nil {
t.Fatalf("expect no operation error, got %v", err)
}
})
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
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"
)
// Use this operation to delete an Earth Observation job.
func (c *Client) DeleteEarthObservationJob(ctx context.Context, params *DeleteEarthObservationJobInput, optFns ...func(*Options)) (*DeleteEarthObservationJobOutput, error) {
if params == nil {
params = &DeleteEarthObservationJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteEarthObservationJob", params, optFns, c.addOperationDeleteEarthObservationJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteEarthObservationJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteEarthObservationJobInput struct {
// The Amazon Resource Name (ARN) of the Earth Observation job being deleted.
//
// This member is required.
Arn *string
noSmithyDocumentSerde
}
type DeleteEarthObservationJobOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteEarthObservationJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteEarthObservationJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteEarthObservationJob{}, 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 = addOpDeleteEarthObservationJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteEarthObservationJob(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_opDeleteEarthObservationJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker-geospatial",
OperationName: "DeleteEarthObservationJob",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
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"
)
// Use this operation to delete a Vector Enrichment job.
func (c *Client) DeleteVectorEnrichmentJob(ctx context.Context, params *DeleteVectorEnrichmentJobInput, optFns ...func(*Options)) (*DeleteVectorEnrichmentJobOutput, error) {
if params == nil {
params = &DeleteVectorEnrichmentJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteVectorEnrichmentJob", params, optFns, c.addOperationDeleteVectorEnrichmentJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteVectorEnrichmentJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteVectorEnrichmentJobInput struct {
// The Amazon Resource Name (ARN) of the Vector Enrichment job being deleted.
//
// This member is required.
Arn *string
noSmithyDocumentSerde
}
type DeleteVectorEnrichmentJobOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteVectorEnrichmentJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteVectorEnrichmentJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteVectorEnrichmentJob{}, 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 = addOpDeleteVectorEnrichmentJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteVectorEnrichmentJob(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_opDeleteVectorEnrichmentJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker-geospatial",
OperationName: "DeleteVectorEnrichmentJob",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/sagemakergeospatial/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Use this operation to export results of an Earth Observation job and optionally
// source images used as input to the EOJ to an Amazon S3 location.
func (c *Client) ExportEarthObservationJob(ctx context.Context, params *ExportEarthObservationJobInput, optFns ...func(*Options)) (*ExportEarthObservationJobOutput, error) {
if params == nil {
params = &ExportEarthObservationJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ExportEarthObservationJob", params, optFns, c.addOperationExportEarthObservationJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ExportEarthObservationJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type ExportEarthObservationJobInput struct {
// The input Amazon Resource Name (ARN) of the Earth Observation job being
// exported.
//
// This member is required.
Arn *string
// The Amazon Resource Name (ARN) of the IAM role that you specified for the job.
//
// This member is required.
ExecutionRoleArn *string
// An object containing information about the output file.
//
// This member is required.
OutputConfig *types.OutputConfigInput
// A unique token that guarantees that the call to this API is idempotent.
ClientToken *string
// The source images provided to the Earth Observation job being exported.
ExportSourceImages *bool
noSmithyDocumentSerde
}
type ExportEarthObservationJobOutput struct {
// The output Amazon Resource Name (ARN) of the Earth Observation job being
// exported.
//
// This member is required.
Arn *string
// The creation time.
//
// This member is required.
CreationTime *time.Time
// The Amazon Resource Name (ARN) of the IAM role that you specified for the job.
//
// This member is required.
ExecutionRoleArn *string
// The status of the results of the Earth Observation job being exported.
//
// This member is required.
ExportStatus types.EarthObservationJobExportStatus
// An object containing information about the output file.
//
// This member is required.
OutputConfig *types.OutputConfigInput
// The source images provided to the Earth Observation job being exported.
ExportSourceImages *bool
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationExportEarthObservationJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpExportEarthObservationJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpExportEarthObservationJob{}, 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 = addIdempotencyToken_opExportEarthObservationJobMiddleware(stack, options); err != nil {
return err
}
if err = addOpExportEarthObservationJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opExportEarthObservationJob(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
}
type idempotencyToken_initializeOpExportEarthObservationJob struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpExportEarthObservationJob) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpExportEarthObservationJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*ExportEarthObservationJobInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *ExportEarthObservationJobInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opExportEarthObservationJobMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpExportEarthObservationJob{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opExportEarthObservationJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker-geospatial",
OperationName: "ExportEarthObservationJob",
}
}
| 207 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/sagemakergeospatial/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Use this operation to copy results of a Vector Enrichment job to an Amazon S3
// location.
func (c *Client) ExportVectorEnrichmentJob(ctx context.Context, params *ExportVectorEnrichmentJobInput, optFns ...func(*Options)) (*ExportVectorEnrichmentJobOutput, error) {
if params == nil {
params = &ExportVectorEnrichmentJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ExportVectorEnrichmentJob", params, optFns, c.addOperationExportVectorEnrichmentJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ExportVectorEnrichmentJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type ExportVectorEnrichmentJobInput struct {
// The Amazon Resource Name (ARN) of the Vector Enrichment job.
//
// This member is required.
Arn *string
// The Amazon Resource Name (ARN) of the IAM rolewith permission to upload to the
// location in OutputConfig.
//
// This member is required.
ExecutionRoleArn *string
// Output location information for exporting Vector Enrichment Job results.
//
// This member is required.
OutputConfig *types.ExportVectorEnrichmentJobOutputConfig
// A unique token that guarantees that the call to this API is idempotent.
ClientToken *string
noSmithyDocumentSerde
}
type ExportVectorEnrichmentJobOutput struct {
// The Amazon Resource Name (ARN) of the Vector Enrichment job being exported.
//
// This member is required.
Arn *string
// The creation time.
//
// This member is required.
CreationTime *time.Time
// The Amazon Resource Name (ARN) of the IAM role with permission to upload to the
// location in OutputConfig.
//
// This member is required.
ExecutionRoleArn *string
// The status of the results the Vector Enrichment job being exported.
//
// This member is required.
ExportStatus types.VectorEnrichmentJobExportStatus
// Output location information for exporting Vector Enrichment Job results.
//
// This member is required.
OutputConfig *types.ExportVectorEnrichmentJobOutputConfig
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationExportVectorEnrichmentJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpExportVectorEnrichmentJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpExportVectorEnrichmentJob{}, 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 = addIdempotencyToken_opExportVectorEnrichmentJobMiddleware(stack, options); err != nil {
return err
}
if err = addOpExportVectorEnrichmentJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opExportVectorEnrichmentJob(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
}
type idempotencyToken_initializeOpExportVectorEnrichmentJob struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpExportVectorEnrichmentJob) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpExportVectorEnrichmentJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*ExportVectorEnrichmentJobInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *ExportVectorEnrichmentJobInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opExportVectorEnrichmentJobMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpExportVectorEnrichmentJob{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opExportVectorEnrichmentJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker-geospatial",
OperationName: "ExportVectorEnrichmentJob",
}
}
| 201 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
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/aws-sdk-go-v2/service/sagemakergeospatial/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Get the details for a previously initiated Earth Observation job.
func (c *Client) GetEarthObservationJob(ctx context.Context, params *GetEarthObservationJobInput, optFns ...func(*Options)) (*GetEarthObservationJobOutput, error) {
if params == nil {
params = &GetEarthObservationJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetEarthObservationJob", params, optFns, c.addOperationGetEarthObservationJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetEarthObservationJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetEarthObservationJobInput struct {
// The Amazon Resource Name (ARN) of the Earth Observation job.
//
// This member is required.
Arn *string
noSmithyDocumentSerde
}
type GetEarthObservationJobOutput struct {
// The Amazon Resource Name (ARN) of the Earth Observation job.
//
// This member is required.
Arn *string
// The creation time of the initiated Earth Observation job.
//
// This member is required.
CreationTime *time.Time
// The duration of Earth Observation job, in seconds.
//
// This member is required.
DurationInSeconds *int32
// Input data for the Earth Observation job.
//
// This member is required.
InputConfig *types.InputConfigOutput
// An object containing information about the job configuration.
//
// This member is required.
JobConfig types.JobConfigInput
// The name of the Earth Observation job.
//
// This member is required.
Name *string
// The status of a previously initiated Earth Observation job.
//
// This member is required.
Status types.EarthObservationJobStatus
// Details about the errors generated during the Earth Observation job.
ErrorDetails *types.EarthObservationJobErrorDetails
// The Amazon Resource Name (ARN) of the IAM role that you specified for the job.
ExecutionRoleArn *string
// Details about the errors generated during ExportEarthObservationJob.
ExportErrorDetails *types.ExportErrorDetails
// The status of the Earth Observation job.
ExportStatus types.EarthObservationJobExportStatus
// The Key Management Service key ID for server-side encryption.
KmsKeyId *string
// Bands available in the output of an operation.
OutputBands []types.OutputBand
// Each tag consists of a key and a value.
Tags map[string]string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetEarthObservationJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetEarthObservationJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetEarthObservationJob{}, 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 = addOpGetEarthObservationJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetEarthObservationJob(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_opGetEarthObservationJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker-geospatial",
OperationName: "GetEarthObservationJob",
}
}
| 179 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
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/aws-sdk-go-v2/service/sagemakergeospatial/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Use this operation to get details of a specific raster data collection.
func (c *Client) GetRasterDataCollection(ctx context.Context, params *GetRasterDataCollectionInput, optFns ...func(*Options)) (*GetRasterDataCollectionOutput, error) {
if params == nil {
params = &GetRasterDataCollectionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetRasterDataCollection", params, optFns, c.addOperationGetRasterDataCollectionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetRasterDataCollectionOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetRasterDataCollectionInput struct {
// The Amazon Resource Name (ARN) of the raster data collection.
//
// This member is required.
Arn *string
noSmithyDocumentSerde
}
type GetRasterDataCollectionOutput struct {
// The Amazon Resource Name (ARN) of the raster data collection.
//
// This member is required.
Arn *string
// A description of the raster data collection.
//
// This member is required.
Description *string
// The URL of the description page.
//
// This member is required.
DescriptionPageUrl *string
// The list of image source bands in the raster data collection.
//
// This member is required.
ImageSourceBands []string
// The name of the raster data collection.
//
// This member is required.
Name *string
// The filters supported by the raster data collection.
//
// This member is required.
SupportedFilters []types.Filter
// The raster data collection type.
//
// This member is required.
Type types.DataCollectionType
// Each tag consists of a key and a value.
Tags map[string]string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetRasterDataCollectionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetRasterDataCollection{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetRasterDataCollection{}, 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 = addOpGetRasterDataCollectionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetRasterDataCollection(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_opGetRasterDataCollection(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker-geospatial",
OperationName: "GetRasterDataCollection",
}
}
| 160 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
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/aws-sdk-go-v2/service/sagemakergeospatial/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io"
)
// Gets a web mercator tile for the given Earth Observation job.
func (c *Client) GetTile(ctx context.Context, params *GetTileInput, optFns ...func(*Options)) (*GetTileOutput, error) {
if params == nil {
params = &GetTileInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetTile", params, optFns, c.addOperationGetTileMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetTileOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetTileInput struct {
// The Amazon Resource Name (ARN) of the tile operation.
//
// This member is required.
Arn *string
// The particular assets or bands to tile.
//
// This member is required.
ImageAssets []string
// Determines what part of the Earth Observation job to tile. 'INPUT' or 'OUTPUT'
// are the valid options.
//
// This member is required.
Target types.TargetOptions
// The x coordinate of the tile input.
//
// This member is required.
X *int32
// The y coordinate of the tile input.
//
// This member is required.
Y *int32
// The z coordinate of the tile input.
//
// This member is required.
Z *int32
// The Amazon Resource Name (ARN) of the IAM role that you specify.
ExecutionRoleArn *string
// Determines whether or not to return a valid data mask.
ImageMask *bool
// The output data type of the tile operation.
OutputDataType types.OutputType
// The data format of the output tile. The formats include .npy, .png and .jpg.
OutputFormat *string
// Property filters for the imagery to tile.
PropertyFilters *string
// Time range filter applied to imagery to find the images to tile.
TimeRangeFilter *string
noSmithyDocumentSerde
}
type GetTileOutput struct {
// The output binary file.
//
// This value conforms to the media type: application/x-binary
BinaryFile io.ReadCloser
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetTileMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetTile{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetTile{}, 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 = addOpGetTileValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetTile(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_opGetTile(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker-geospatial",
OperationName: "GetTile",
}
}
| 169 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
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/aws-sdk-go-v2/service/sagemakergeospatial/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Retrieves details of a Vector Enrichment Job for a given job Amazon Resource
// Name (ARN).
func (c *Client) GetVectorEnrichmentJob(ctx context.Context, params *GetVectorEnrichmentJobInput, optFns ...func(*Options)) (*GetVectorEnrichmentJobOutput, error) {
if params == nil {
params = &GetVectorEnrichmentJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetVectorEnrichmentJob", params, optFns, c.addOperationGetVectorEnrichmentJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetVectorEnrichmentJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetVectorEnrichmentJobInput struct {
// The Amazon Resource Name (ARN) of the Vector Enrichment job.
//
// This member is required.
Arn *string
noSmithyDocumentSerde
}
type GetVectorEnrichmentJobOutput struct {
// The Amazon Resource Name (ARN) of the Vector Enrichment job.
//
// This member is required.
Arn *string
// The creation time.
//
// This member is required.
CreationTime *time.Time
// The duration of the Vector Enrichment job, in seconds.
//
// This member is required.
DurationInSeconds *int32
// The Amazon Resource Name (ARN) of the IAM role that you specified for the job.
//
// This member is required.
ExecutionRoleArn *string
// Input configuration information for the Vector Enrichment job.
//
// This member is required.
InputConfig *types.VectorEnrichmentJobInputConfig
// An object containing information about the job configuration.
//
// This member is required.
JobConfig types.VectorEnrichmentJobConfig
// The name of the Vector Enrichment job.
//
// This member is required.
Name *string
// The status of the initiated Vector Enrichment job.
//
// This member is required.
Status types.VectorEnrichmentJobStatus
// The type of the Vector Enrichment job being initiated.
//
// This member is required.
Type types.VectorEnrichmentJobType
// Details about the errors generated during the Vector Enrichment job.
ErrorDetails *types.VectorEnrichmentJobErrorDetails
// Details about the errors generated during the ExportVectorEnrichmentJob.
ExportErrorDetails *types.VectorEnrichmentJobExportErrorDetails
// The export status of the Vector Enrichment job being initiated.
ExportStatus types.VectorEnrichmentJobExportStatus
// The Key Management Service key ID for server-side encryption.
KmsKeyId *string
// Each tag consists of a key and a value.
Tags map[string]string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetVectorEnrichmentJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetVectorEnrichmentJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetVectorEnrichmentJob{}, 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 = addOpGetVectorEnrichmentJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetVectorEnrichmentJob(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_opGetVectorEnrichmentJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker-geospatial",
OperationName: "GetVectorEnrichmentJob",
}
}
| 184 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/sagemakergeospatial/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Use this operation to get a list of the Earth Observation jobs associated with
// the calling Amazon Web Services account.
func (c *Client) ListEarthObservationJobs(ctx context.Context, params *ListEarthObservationJobsInput, optFns ...func(*Options)) (*ListEarthObservationJobsOutput, error) {
if params == nil {
params = &ListEarthObservationJobsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListEarthObservationJobs", params, optFns, c.addOperationListEarthObservationJobsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListEarthObservationJobsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListEarthObservationJobsInput struct {
// The total number of items to return.
MaxResults *int32
// If the previous response was truncated, you receive this token. Use it in your
// next request to receive the next set of results.
NextToken *string
// The parameter by which to sort the results.
SortBy *string
// An optional value that specifies whether you want the results sorted in
// Ascending or Descending order.
SortOrder types.SortOrder
// A filter that retrieves only jobs with a specific status.
StatusEquals types.EarthObservationJobStatus
noSmithyDocumentSerde
}
type ListEarthObservationJobsOutput struct {
// Contains summary information about the Earth Observation jobs.
//
// This member is required.
EarthObservationJobSummaries []types.ListEarthObservationJobOutputConfig
// If the previous response was truncated, you receive this token. Use it in your
// next request to receive the next set of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListEarthObservationJobsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListEarthObservationJobs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListEarthObservationJobs{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opListEarthObservationJobs(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
}
// ListEarthObservationJobsAPIClient is a client that implements the
// ListEarthObservationJobs operation.
type ListEarthObservationJobsAPIClient interface {
ListEarthObservationJobs(context.Context, *ListEarthObservationJobsInput, ...func(*Options)) (*ListEarthObservationJobsOutput, error)
}
var _ ListEarthObservationJobsAPIClient = (*Client)(nil)
// ListEarthObservationJobsPaginatorOptions is the paginator options for
// ListEarthObservationJobs
type ListEarthObservationJobsPaginatorOptions struct {
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListEarthObservationJobsPaginator is a paginator for ListEarthObservationJobs
type ListEarthObservationJobsPaginator struct {
options ListEarthObservationJobsPaginatorOptions
client ListEarthObservationJobsAPIClient
params *ListEarthObservationJobsInput
nextToken *string
firstPage bool
}
// NewListEarthObservationJobsPaginator returns a new
// ListEarthObservationJobsPaginator
func NewListEarthObservationJobsPaginator(client ListEarthObservationJobsAPIClient, params *ListEarthObservationJobsInput, optFns ...func(*ListEarthObservationJobsPaginatorOptions)) *ListEarthObservationJobsPaginator {
if params == nil {
params = &ListEarthObservationJobsInput{}
}
options := ListEarthObservationJobsPaginatorOptions{}
for _, fn := range optFns {
fn(&options)
}
return &ListEarthObservationJobsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListEarthObservationJobsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListEarthObservationJobs page.
func (p *ListEarthObservationJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListEarthObservationJobsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
result, err := p.client.ListEarthObservationJobs(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListEarthObservationJobs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker-geospatial",
OperationName: "ListEarthObservationJobs",
}
}
| 222 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/sagemakergeospatial/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Use this operation to get raster data collections.
func (c *Client) ListRasterDataCollections(ctx context.Context, params *ListRasterDataCollectionsInput, optFns ...func(*Options)) (*ListRasterDataCollectionsOutput, error) {
if params == nil {
params = &ListRasterDataCollectionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListRasterDataCollections", params, optFns, c.addOperationListRasterDataCollectionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListRasterDataCollectionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListRasterDataCollectionsInput struct {
// The total number of items to return.
MaxResults *int32
// If the previous response was truncated, you receive this token. Use it in your
// next request to receive the next set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListRasterDataCollectionsOutput struct {
// Contains summary information about the raster data collection.
//
// This member is required.
RasterDataCollectionSummaries []types.RasterDataCollectionMetadata
// If the previous response was truncated, you receive this token. Use it in your
// next request to receive the next set of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListRasterDataCollectionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListRasterDataCollections{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListRasterDataCollections{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opListRasterDataCollections(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
}
// ListRasterDataCollectionsAPIClient is a client that implements the
// ListRasterDataCollections operation.
type ListRasterDataCollectionsAPIClient interface {
ListRasterDataCollections(context.Context, *ListRasterDataCollectionsInput, ...func(*Options)) (*ListRasterDataCollectionsOutput, error)
}
var _ ListRasterDataCollectionsAPIClient = (*Client)(nil)
// ListRasterDataCollectionsPaginatorOptions is the paginator options for
// ListRasterDataCollections
type ListRasterDataCollectionsPaginatorOptions struct {
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListRasterDataCollectionsPaginator is a paginator for ListRasterDataCollections
type ListRasterDataCollectionsPaginator struct {
options ListRasterDataCollectionsPaginatorOptions
client ListRasterDataCollectionsAPIClient
params *ListRasterDataCollectionsInput
nextToken *string
firstPage bool
}
// NewListRasterDataCollectionsPaginator returns a new
// ListRasterDataCollectionsPaginator
func NewListRasterDataCollectionsPaginator(client ListRasterDataCollectionsAPIClient, params *ListRasterDataCollectionsInput, optFns ...func(*ListRasterDataCollectionsPaginatorOptions)) *ListRasterDataCollectionsPaginator {
if params == nil {
params = &ListRasterDataCollectionsInput{}
}
options := ListRasterDataCollectionsPaginatorOptions{}
for _, fn := range optFns {
fn(&options)
}
return &ListRasterDataCollectionsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListRasterDataCollectionsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListRasterDataCollections page.
func (p *ListRasterDataCollectionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListRasterDataCollectionsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
result, err := p.client.ListRasterDataCollections(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListRasterDataCollections(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker-geospatial",
OperationName: "ListRasterDataCollections",
}
}
| 211 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
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"
)
// Lists the tags attached to the resource.
func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error) {
if params == nil {
params = &ListTagsForResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListTagsForResource", params, optFns, c.addOperationListTagsForResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListTagsForResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListTagsForResourceInput struct {
// The Amazon Resource Name (ARN) of the resource you want to tag.
//
// This member is required.
ResourceArn *string
noSmithyDocumentSerde
}
type ListTagsForResourceOutput struct {
// Each tag consists of a key and a value.
Tags map[string]string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListTagsForResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListTagsForResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListTagsForResource{}, 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 = addOpListTagsForResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListTagsForResource(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_opListTagsForResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker-geospatial",
OperationName: "ListTagsForResource",
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/sagemakergeospatial/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a list of vector enrichment jobs.
func (c *Client) ListVectorEnrichmentJobs(ctx context.Context, params *ListVectorEnrichmentJobsInput, optFns ...func(*Options)) (*ListVectorEnrichmentJobsOutput, error) {
if params == nil {
params = &ListVectorEnrichmentJobsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListVectorEnrichmentJobs", params, optFns, c.addOperationListVectorEnrichmentJobsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListVectorEnrichmentJobsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListVectorEnrichmentJobsInput struct {
// The maximum number of items to return.
MaxResults *int32
// If the previous response was truncated, you receive this token. Use it in your
// next request to receive the next set of results.
NextToken *string
// The parameter by which to sort the results.
SortBy *string
// An optional value that specifies whether you want the results sorted in
// Ascending or Descending order.
SortOrder types.SortOrder
// A filter that retrieves only jobs with a specific status.
StatusEquals *string
noSmithyDocumentSerde
}
type ListVectorEnrichmentJobsOutput struct {
// Contains summary information about the Vector Enrichment jobs.
//
// This member is required.
VectorEnrichmentJobSummaries []types.ListVectorEnrichmentJobOutputConfig
// If the previous response was truncated, you receive this token. Use it in your
// next request to receive the next set of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListVectorEnrichmentJobsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListVectorEnrichmentJobs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListVectorEnrichmentJobs{}, 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 = stack.Initialize.Add(newServiceMetadataMiddleware_opListVectorEnrichmentJobs(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
}
// ListVectorEnrichmentJobsAPIClient is a client that implements the
// ListVectorEnrichmentJobs operation.
type ListVectorEnrichmentJobsAPIClient interface {
ListVectorEnrichmentJobs(context.Context, *ListVectorEnrichmentJobsInput, ...func(*Options)) (*ListVectorEnrichmentJobsOutput, error)
}
var _ ListVectorEnrichmentJobsAPIClient = (*Client)(nil)
// ListVectorEnrichmentJobsPaginatorOptions is the paginator options for
// ListVectorEnrichmentJobs
type ListVectorEnrichmentJobsPaginatorOptions struct {
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListVectorEnrichmentJobsPaginator is a paginator for ListVectorEnrichmentJobs
type ListVectorEnrichmentJobsPaginator struct {
options ListVectorEnrichmentJobsPaginatorOptions
client ListVectorEnrichmentJobsAPIClient
params *ListVectorEnrichmentJobsInput
nextToken *string
firstPage bool
}
// NewListVectorEnrichmentJobsPaginator returns a new
// ListVectorEnrichmentJobsPaginator
func NewListVectorEnrichmentJobsPaginator(client ListVectorEnrichmentJobsAPIClient, params *ListVectorEnrichmentJobsInput, optFns ...func(*ListVectorEnrichmentJobsPaginatorOptions)) *ListVectorEnrichmentJobsPaginator {
if params == nil {
params = &ListVectorEnrichmentJobsInput{}
}
options := ListVectorEnrichmentJobsPaginatorOptions{}
for _, fn := range optFns {
fn(&options)
}
return &ListVectorEnrichmentJobsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListVectorEnrichmentJobsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListVectorEnrichmentJobs page.
func (p *ListVectorEnrichmentJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListVectorEnrichmentJobsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
result, err := p.client.ListVectorEnrichmentJobs(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListVectorEnrichmentJobs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker-geospatial",
OperationName: "ListVectorEnrichmentJobs",
}
}
| 221 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/sagemakergeospatial/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Allows you run image query on a specific raster data collection to get a list
// of the satellite imagery matching the selected filters.
func (c *Client) SearchRasterDataCollection(ctx context.Context, params *SearchRasterDataCollectionInput, optFns ...func(*Options)) (*SearchRasterDataCollectionOutput, error) {
if params == nil {
params = &SearchRasterDataCollectionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "SearchRasterDataCollection", params, optFns, c.addOperationSearchRasterDataCollectionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*SearchRasterDataCollectionOutput)
out.ResultMetadata = metadata
return out, nil
}
type SearchRasterDataCollectionInput struct {
// The Amazon Resource Name (ARN) of the raster data collection.
//
// This member is required.
Arn *string
// RasterDataCollectionQuery consisting of AreaOfInterest(AOI) (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_geospatial_AreaOfInterest.html)
// , PropertyFilters (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_geospatial_PropertyFilter.html)
// and TimeRangeFilterInput (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_geospatial_TimeRangeFilterInput.html)
// used in SearchRasterDataCollection (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_geospatial_SearchRasterDataCollection.html)
// .
//
// This member is required.
RasterDataCollectionQuery *types.RasterDataCollectionQueryWithBandFilterInput
// If the previous response was truncated, you receive this token. Use it in your
// next request to receive the next set of results.
NextToken *string
noSmithyDocumentSerde
}
type SearchRasterDataCollectionOutput struct {
// Approximate number of results in the response.
//
// This member is required.
ApproximateResultCount *int32
// List of items matching the Raster DataCollectionQuery.
Items []types.ItemSource
// If the previous response was truncated, you receive this token. Use it in your
// next request to receive the next set of results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationSearchRasterDataCollectionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpSearchRasterDataCollection{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpSearchRasterDataCollection{}, 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 = addOpSearchRasterDataCollectionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opSearchRasterDataCollection(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
}
// SearchRasterDataCollectionAPIClient is a client that implements the
// SearchRasterDataCollection operation.
type SearchRasterDataCollectionAPIClient interface {
SearchRasterDataCollection(context.Context, *SearchRasterDataCollectionInput, ...func(*Options)) (*SearchRasterDataCollectionOutput, error)
}
var _ SearchRasterDataCollectionAPIClient = (*Client)(nil)
// SearchRasterDataCollectionPaginatorOptions is the paginator options for
// SearchRasterDataCollection
type SearchRasterDataCollectionPaginatorOptions struct {
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// SearchRasterDataCollectionPaginator is a paginator for
// SearchRasterDataCollection
type SearchRasterDataCollectionPaginator struct {
options SearchRasterDataCollectionPaginatorOptions
client SearchRasterDataCollectionAPIClient
params *SearchRasterDataCollectionInput
nextToken *string
firstPage bool
}
// NewSearchRasterDataCollectionPaginator returns a new
// SearchRasterDataCollectionPaginator
func NewSearchRasterDataCollectionPaginator(client SearchRasterDataCollectionAPIClient, params *SearchRasterDataCollectionInput, optFns ...func(*SearchRasterDataCollectionPaginatorOptions)) *SearchRasterDataCollectionPaginator {
if params == nil {
params = &SearchRasterDataCollectionInput{}
}
options := SearchRasterDataCollectionPaginatorOptions{}
for _, fn := range optFns {
fn(&options)
}
return &SearchRasterDataCollectionPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *SearchRasterDataCollectionPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next SearchRasterDataCollection page.
func (p *SearchRasterDataCollectionPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*SearchRasterDataCollectionOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
result, err := p.client.SearchRasterDataCollection(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opSearchRasterDataCollection(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker-geospatial",
OperationName: "SearchRasterDataCollection",
}
}
| 230 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/sagemakergeospatial/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Use this operation to create an Earth observation job.
func (c *Client) StartEarthObservationJob(ctx context.Context, params *StartEarthObservationJobInput, optFns ...func(*Options)) (*StartEarthObservationJobOutput, error) {
if params == nil {
params = &StartEarthObservationJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartEarthObservationJob", params, optFns, c.addOperationStartEarthObservationJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartEarthObservationJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartEarthObservationJobInput struct {
// The Amazon Resource Name (ARN) of the IAM role that you specified for the job.
//
// This member is required.
ExecutionRoleArn *string
// Input configuration information for the Earth Observation job.
//
// This member is required.
InputConfig *types.InputConfigInput
// An object containing information about the job configuration.
//
// This member is required.
JobConfig types.JobConfigInput
// The name of the Earth Observation job.
//
// This member is required.
Name *string
// A unique token that guarantees that the call to this API is idempotent.
ClientToken *string
// The Key Management Service key ID for server-side encryption.
KmsKeyId *string
// Each tag consists of a key and a value.
Tags map[string]string
noSmithyDocumentSerde
}
type StartEarthObservationJobOutput struct {
// The Amazon Resource Name (ARN) of the Earth Observation job.
//
// This member is required.
Arn *string
// The creation time.
//
// This member is required.
CreationTime *time.Time
// The duration of the session, in seconds.
//
// This member is required.
DurationInSeconds *int32
// The Amazon Resource Name (ARN) of the IAM role that you specified for the job.
//
// This member is required.
ExecutionRoleArn *string
// An object containing information about the job configuration.
//
// This member is required.
JobConfig types.JobConfigInput
// The name of the Earth Observation job.
//
// This member is required.
Name *string
// The status of the Earth Observation job.
//
// This member is required.
Status types.EarthObservationJobStatus
// Input configuration information for the Earth Observation job.
InputConfig *types.InputConfigOutput
// The Key Management Service key ID for server-side encryption.
KmsKeyId *string
// Each tag consists of a key and a value.
Tags map[string]string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartEarthObservationJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartEarthObservationJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartEarthObservationJob{}, 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 = addIdempotencyToken_opStartEarthObservationJobMiddleware(stack, options); err != nil {
return err
}
if err = addOpStartEarthObservationJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartEarthObservationJob(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
}
type idempotencyToken_initializeOpStartEarthObservationJob struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpStartEarthObservationJob) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpStartEarthObservationJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*StartEarthObservationJobInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *StartEarthObservationJobInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opStartEarthObservationJobMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpStartEarthObservationJob{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opStartEarthObservationJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker-geospatial",
OperationName: "StartEarthObservationJob",
}
}
| 228 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/sagemakergeospatial/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Creates a Vector Enrichment job for the supplied job type. Currently, there are
// two supported job types: reverse geocoding and map matching.
func (c *Client) StartVectorEnrichmentJob(ctx context.Context, params *StartVectorEnrichmentJobInput, optFns ...func(*Options)) (*StartVectorEnrichmentJobOutput, error) {
if params == nil {
params = &StartVectorEnrichmentJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartVectorEnrichmentJob", params, optFns, c.addOperationStartVectorEnrichmentJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartVectorEnrichmentJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartVectorEnrichmentJobInput struct {
// The Amazon Resource Name (ARN) of the IAM role that you specified for the job.
//
// This member is required.
ExecutionRoleArn *string
// Input configuration information for the Vector Enrichment job.
//
// This member is required.
InputConfig *types.VectorEnrichmentJobInputConfig
// An object containing information about the job configuration.
//
// This member is required.
JobConfig types.VectorEnrichmentJobConfig
// The name of the Vector Enrichment job.
//
// This member is required.
Name *string
// A unique token that guarantees that the call to this API is idempotent.
ClientToken *string
// The Key Management Service key ID for server-side encryption.
KmsKeyId *string
// Each tag consists of a key and a value.
Tags map[string]string
noSmithyDocumentSerde
}
type StartVectorEnrichmentJobOutput struct {
// The Amazon Resource Name (ARN) of the Vector Enrichment job.
//
// This member is required.
Arn *string
// The creation time.
//
// This member is required.
CreationTime *time.Time
// The duration of the Vector Enrichment job, in seconds.
//
// This member is required.
DurationInSeconds *int32
// The Amazon Resource Name (ARN) of the IAM role that you specified for the job.
//
// This member is required.
ExecutionRoleArn *string
// Input configuration information for starting the Vector Enrichment job.
//
// This member is required.
InputConfig *types.VectorEnrichmentJobInputConfig
// An object containing information about the job configuration.
//
// This member is required.
JobConfig types.VectorEnrichmentJobConfig
// The name of the Vector Enrichment job.
//
// This member is required.
Name *string
// The status of the Vector Enrichment job being started.
//
// This member is required.
Status types.VectorEnrichmentJobStatus
// The type of the Vector Enrichment job.
//
// This member is required.
Type types.VectorEnrichmentJobType
// The Key Management Service key ID for server-side encryption.
KmsKeyId *string
// Each tag consists of a key and a value.
Tags map[string]string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartVectorEnrichmentJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartVectorEnrichmentJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartVectorEnrichmentJob{}, 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 = addIdempotencyToken_opStartVectorEnrichmentJobMiddleware(stack, options); err != nil {
return err
}
if err = addOpStartVectorEnrichmentJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartVectorEnrichmentJob(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
}
type idempotencyToken_initializeOpStartVectorEnrichmentJob struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpStartVectorEnrichmentJob) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpStartVectorEnrichmentJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*StartVectorEnrichmentJobInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *StartVectorEnrichmentJobInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opStartVectorEnrichmentJobMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpStartVectorEnrichmentJob{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opStartVectorEnrichmentJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker-geospatial",
OperationName: "StartVectorEnrichmentJob",
}
}
| 236 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
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"
)
// Use this operation to stop an existing earth observation job.
func (c *Client) StopEarthObservationJob(ctx context.Context, params *StopEarthObservationJobInput, optFns ...func(*Options)) (*StopEarthObservationJobOutput, error) {
if params == nil {
params = &StopEarthObservationJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StopEarthObservationJob", params, optFns, c.addOperationStopEarthObservationJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StopEarthObservationJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type StopEarthObservationJobInput struct {
// The Amazon Resource Name (ARN) of the Earth Observation job being stopped.
//
// This member is required.
Arn *string
noSmithyDocumentSerde
}
type StopEarthObservationJobOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStopEarthObservationJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStopEarthObservationJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStopEarthObservationJob{}, 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 = addOpStopEarthObservationJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStopEarthObservationJob(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_opStopEarthObservationJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker-geospatial",
OperationName: "StopEarthObservationJob",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
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"
)
// Stops the Vector Enrichment job for a given job ARN.
func (c *Client) StopVectorEnrichmentJob(ctx context.Context, params *StopVectorEnrichmentJobInput, optFns ...func(*Options)) (*StopVectorEnrichmentJobOutput, error) {
if params == nil {
params = &StopVectorEnrichmentJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StopVectorEnrichmentJob", params, optFns, c.addOperationStopVectorEnrichmentJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StopVectorEnrichmentJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type StopVectorEnrichmentJobInput struct {
// The Amazon Resource Name (ARN) of the Vector Enrichment job.
//
// This member is required.
Arn *string
noSmithyDocumentSerde
}
type StopVectorEnrichmentJobOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStopVectorEnrichmentJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStopVectorEnrichmentJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStopVectorEnrichmentJob{}, 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 = addOpStopVectorEnrichmentJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStopVectorEnrichmentJob(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_opStopVectorEnrichmentJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker-geospatial",
OperationName: "StopVectorEnrichmentJob",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
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"
)
// The resource you want to tag.
func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error) {
if params == nil {
params = &TagResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "TagResource", params, optFns, c.addOperationTagResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*TagResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type TagResourceInput struct {
// The Amazon Resource Name (ARN) of the resource you want to tag.
//
// This member is required.
ResourceArn *string
// Each tag consists of a key and a value.
//
// This member is required.
Tags map[string]string
noSmithyDocumentSerde
}
type TagResourceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationTagResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpTagResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpTagResource{}, 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 = addOpTagResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opTagResource(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_opTagResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker-geospatial",
OperationName: "TagResource",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
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"
)
// The resource you want to untag.
func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error) {
if params == nil {
params = &UntagResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UntagResource", params, optFns, c.addOperationUntagResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UntagResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type UntagResourceInput struct {
// The Amazon Resource Name (ARN) of the resource you want to untag.
//
// This member is required.
ResourceArn *string
// Keys of the tags you want to remove.
//
// This member is required.
TagKeys []string
noSmithyDocumentSerde
}
type UntagResourceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUntagResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUntagResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUntagResource{}, 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 = addOpUntagResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUntagResource(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_opUntagResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker-geospatial",
OperationName: "UntagResource",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
import (
"bytes"
"context"
"encoding/json"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
"github.com/aws/aws-sdk-go-v2/service/sagemakergeospatial/types"
smithy "github.com/aws/smithy-go"
smithyio "github.com/aws/smithy-go/io"
"github.com/aws/smithy-go/middleware"
"github.com/aws/smithy-go/ptr"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io"
"math"
"strings"
)
type awsRestjson1_deserializeOpDeleteEarthObservationJob struct {
}
func (*awsRestjson1_deserializeOpDeleteEarthObservationJob) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeleteEarthObservationJob) 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_deserializeOpErrorDeleteEarthObservationJob(response, &metadata)
}
output := &DeleteEarthObservationJobOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDeleteEarthObservationJob(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("ConflictException", errorCode):
return awsRestjson1_deserializeErrorConflictException(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
}
}
type awsRestjson1_deserializeOpDeleteVectorEnrichmentJob struct {
}
func (*awsRestjson1_deserializeOpDeleteVectorEnrichmentJob) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeleteVectorEnrichmentJob) 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_deserializeOpErrorDeleteVectorEnrichmentJob(response, &metadata)
}
output := &DeleteVectorEnrichmentJobOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDeleteVectorEnrichmentJob(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("ConflictException", errorCode):
return awsRestjson1_deserializeErrorConflictException(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
}
}
type awsRestjson1_deserializeOpExportEarthObservationJob struct {
}
func (*awsRestjson1_deserializeOpExportEarthObservationJob) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpExportEarthObservationJob) 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_deserializeOpErrorExportEarthObservationJob(response, &metadata)
}
output := &ExportEarthObservationJobOutput{}
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_deserializeOpDocumentExportEarthObservationJobOutput(&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_deserializeOpErrorExportEarthObservationJob(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("ConflictException", errorCode):
return awsRestjson1_deserializeErrorConflictException(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("ServiceQuotaExceededException", errorCode):
return awsRestjson1_deserializeErrorServiceQuotaExceededException(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_deserializeOpDocumentExportEarthObservationJobOutput(v **ExportEarthObservationJobOutput, 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 *ExportEarthObservationJobOutput
if *v == nil {
sv = &ExportEarthObservationJobOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EarthObservationJobArn to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value)
}
t, err := smithytime.ParseDateTime(jtv)
if err != nil {
return err
}
sv.CreationTime = ptr.Time(t)
}
case "ExecutionRoleArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ExecutionRoleArn to be of type string, got %T instead", value)
}
sv.ExecutionRoleArn = ptr.String(jtv)
}
case "ExportSourceImages":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.ExportSourceImages = ptr.Bool(jtv)
}
case "ExportStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EarthObservationJobExportStatus to be of type string, got %T instead", value)
}
sv.ExportStatus = types.EarthObservationJobExportStatus(jtv)
}
case "OutputConfig":
if err := awsRestjson1_deserializeDocumentOutputConfigInput(&sv.OutputConfig, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpExportVectorEnrichmentJob struct {
}
func (*awsRestjson1_deserializeOpExportVectorEnrichmentJob) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpExportVectorEnrichmentJob) 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_deserializeOpErrorExportVectorEnrichmentJob(response, &metadata)
}
output := &ExportVectorEnrichmentJobOutput{}
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_deserializeOpDocumentExportVectorEnrichmentJobOutput(&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_deserializeOpErrorExportVectorEnrichmentJob(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("ConflictException", errorCode):
return awsRestjson1_deserializeErrorConflictException(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("ServiceQuotaExceededException", errorCode):
return awsRestjson1_deserializeErrorServiceQuotaExceededException(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_deserializeOpDocumentExportVectorEnrichmentJobOutput(v **ExportVectorEnrichmentJobOutput, 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 *ExportVectorEnrichmentJobOutput
if *v == nil {
sv = &ExportVectorEnrichmentJobOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VectorEnrichmentJobArn to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value)
}
t, err := smithytime.ParseDateTime(jtv)
if err != nil {
return err
}
sv.CreationTime = ptr.Time(t)
}
case "ExecutionRoleArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ExecutionRoleArn to be of type string, got %T instead", value)
}
sv.ExecutionRoleArn = ptr.String(jtv)
}
case "ExportStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VectorEnrichmentJobExportStatus to be of type string, got %T instead", value)
}
sv.ExportStatus = types.VectorEnrichmentJobExportStatus(jtv)
}
case "OutputConfig":
if err := awsRestjson1_deserializeDocumentExportVectorEnrichmentJobOutputConfig(&sv.OutputConfig, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetEarthObservationJob struct {
}
func (*awsRestjson1_deserializeOpGetEarthObservationJob) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetEarthObservationJob) 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_deserializeOpErrorGetEarthObservationJob(response, &metadata)
}
output := &GetEarthObservationJobOutput{}
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_deserializeOpDocumentGetEarthObservationJobOutput(&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_deserializeOpErrorGetEarthObservationJob(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_deserializeOpDocumentGetEarthObservationJobOutput(v **GetEarthObservationJobOutput, 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 *GetEarthObservationJobOutput
if *v == nil {
sv = &GetEarthObservationJobOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value)
}
t, err := smithytime.ParseDateTime(jtv)
if err != nil {
return err
}
sv.CreationTime = ptr.Time(t)
}
case "DurationInSeconds":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.DurationInSeconds = ptr.Int32(int32(i64))
}
case "ErrorDetails":
if err := awsRestjson1_deserializeDocumentEarthObservationJobErrorDetails(&sv.ErrorDetails, value); err != nil {
return err
}
case "ExecutionRoleArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ExecutionRoleArn to be of type string, got %T instead", value)
}
sv.ExecutionRoleArn = ptr.String(jtv)
}
case "ExportErrorDetails":
if err := awsRestjson1_deserializeDocumentExportErrorDetails(&sv.ExportErrorDetails, value); err != nil {
return err
}
case "ExportStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EarthObservationJobExportStatus to be of type string, got %T instead", value)
}
sv.ExportStatus = types.EarthObservationJobExportStatus(jtv)
}
case "InputConfig":
if err := awsRestjson1_deserializeDocumentInputConfigOutput(&sv.InputConfig, value); err != nil {
return err
}
case "JobConfig":
if err := awsRestjson1_deserializeDocumentJobConfigInput(&sv.JobConfig, value); err != nil {
return err
}
case "KmsKeyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KmsKey to be of type string, got %T instead", value)
}
sv.KmsKeyId = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "OutputBands":
if err := awsRestjson1_deserializeDocumentEarthObservationJobOutputBands(&sv.OutputBands, value); err != nil {
return err
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EarthObservationJobStatus to be of type string, got %T instead", value)
}
sv.Status = types.EarthObservationJobStatus(jtv)
}
case "Tags":
if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetRasterDataCollection struct {
}
func (*awsRestjson1_deserializeOpGetRasterDataCollection) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetRasterDataCollection) 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_deserializeOpErrorGetRasterDataCollection(response, &metadata)
}
output := &GetRasterDataCollectionOutput{}
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_deserializeOpDocumentGetRasterDataCollectionOutput(&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_deserializeOpErrorGetRasterDataCollection(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_deserializeOpDocumentGetRasterDataCollectionOutput(v **GetRasterDataCollectionOutput, 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 *GetRasterDataCollectionOutput
if *v == nil {
sv = &GetRasterDataCollectionOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DataCollectionArn to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "DescriptionPageUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.DescriptionPageUrl = ptr.String(jtv)
}
case "ImageSourceBands":
if err := awsRestjson1_deserializeDocumentImageSourceBandList(&sv.ImageSourceBands, value); err != nil {
return err
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "SupportedFilters":
if err := awsRestjson1_deserializeDocumentFilterList(&sv.SupportedFilters, value); err != nil {
return err
}
case "Tags":
if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil {
return err
}
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DataCollectionType to be of type string, got %T instead", value)
}
sv.Type = types.DataCollectionType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetTile struct {
}
func (*awsRestjson1_deserializeOpGetTile) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetTile) 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_deserializeOpErrorGetTile(response, &metadata)
}
output := &GetTileOutput{}
out.Result = output
err = awsRestjson1_deserializeOpDocumentGetTileOutput(output, response.Body)
if err != nil {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to deserialize response payload, %w", err)}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorGetTile(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_deserializeOpDocumentGetTileOutput(v *GetTileOutput, body io.ReadCloser) error {
if v == nil {
return fmt.Errorf("unsupported deserialization of nil %T", v)
}
v.BinaryFile = body
return nil
}
type awsRestjson1_deserializeOpGetVectorEnrichmentJob struct {
}
func (*awsRestjson1_deserializeOpGetVectorEnrichmentJob) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetVectorEnrichmentJob) 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_deserializeOpErrorGetVectorEnrichmentJob(response, &metadata)
}
output := &GetVectorEnrichmentJobOutput{}
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_deserializeOpDocumentGetVectorEnrichmentJobOutput(&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_deserializeOpErrorGetVectorEnrichmentJob(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_deserializeOpDocumentGetVectorEnrichmentJobOutput(v **GetVectorEnrichmentJobOutput, 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 *GetVectorEnrichmentJobOutput
if *v == nil {
sv = &GetVectorEnrichmentJobOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value)
}
t, err := smithytime.ParseDateTime(jtv)
if err != nil {
return err
}
sv.CreationTime = ptr.Time(t)
}
case "DurationInSeconds":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.DurationInSeconds = ptr.Int32(int32(i64))
}
case "ErrorDetails":
if err := awsRestjson1_deserializeDocumentVectorEnrichmentJobErrorDetails(&sv.ErrorDetails, value); err != nil {
return err
}
case "ExecutionRoleArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ExecutionRoleArn to be of type string, got %T instead", value)
}
sv.ExecutionRoleArn = ptr.String(jtv)
}
case "ExportErrorDetails":
if err := awsRestjson1_deserializeDocumentVectorEnrichmentJobExportErrorDetails(&sv.ExportErrorDetails, value); err != nil {
return err
}
case "ExportStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VectorEnrichmentJobExportStatus to be of type string, got %T instead", value)
}
sv.ExportStatus = types.VectorEnrichmentJobExportStatus(jtv)
}
case "InputConfig":
if err := awsRestjson1_deserializeDocumentVectorEnrichmentJobInputConfig(&sv.InputConfig, value); err != nil {
return err
}
case "JobConfig":
if err := awsRestjson1_deserializeDocumentVectorEnrichmentJobConfig(&sv.JobConfig, value); err != nil {
return err
}
case "KmsKeyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KmsKey to be of type string, got %T instead", value)
}
sv.KmsKeyId = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VectorEnrichmentJobStatus to be of type string, got %T instead", value)
}
sv.Status = types.VectorEnrichmentJobStatus(jtv)
}
case "Tags":
if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil {
return err
}
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VectorEnrichmentJobType to be of type string, got %T instead", value)
}
sv.Type = types.VectorEnrichmentJobType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListEarthObservationJobs struct {
}
func (*awsRestjson1_deserializeOpListEarthObservationJobs) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListEarthObservationJobs) 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_deserializeOpErrorListEarthObservationJobs(response, &metadata)
}
output := &ListEarthObservationJobsOutput{}
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_deserializeOpDocumentListEarthObservationJobsOutput(&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_deserializeOpErrorListEarthObservationJobs(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_deserializeOpDocumentListEarthObservationJobsOutput(v **ListEarthObservationJobsOutput, 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 *ListEarthObservationJobsOutput
if *v == nil {
sv = &ListEarthObservationJobsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "EarthObservationJobSummaries":
if err := awsRestjson1_deserializeDocumentEarthObservationJobList(&sv.EarthObservationJobSummaries, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListRasterDataCollections struct {
}
func (*awsRestjson1_deserializeOpListRasterDataCollections) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListRasterDataCollections) 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_deserializeOpErrorListRasterDataCollections(response, &metadata)
}
output := &ListRasterDataCollectionsOutput{}
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_deserializeOpDocumentListRasterDataCollectionsOutput(&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_deserializeOpErrorListRasterDataCollections(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_deserializeOpDocumentListRasterDataCollectionsOutput(v **ListRasterDataCollectionsOutput, 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 *ListRasterDataCollectionsOutput
if *v == nil {
sv = &ListRasterDataCollectionsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "RasterDataCollectionSummaries":
if err := awsRestjson1_deserializeDocumentDataCollectionsList(&sv.RasterDataCollectionSummaries, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListTagsForResource struct {
}
func (*awsRestjson1_deserializeOpListTagsForResource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListTagsForResource) 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_deserializeOpErrorListTagsForResource(response, &metadata)
}
output := &ListTagsForResourceOutput{}
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_deserializeOpDocumentListTagsForResourceOutput(&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_deserializeOpErrorListTagsForResource(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_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, 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 *ListTagsForResourceOutput
if *v == nil {
sv = &ListTagsForResourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Tags":
if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListVectorEnrichmentJobs struct {
}
func (*awsRestjson1_deserializeOpListVectorEnrichmentJobs) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListVectorEnrichmentJobs) 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_deserializeOpErrorListVectorEnrichmentJobs(response, &metadata)
}
output := &ListVectorEnrichmentJobsOutput{}
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_deserializeOpDocumentListVectorEnrichmentJobsOutput(&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_deserializeOpErrorListVectorEnrichmentJobs(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_deserializeOpDocumentListVectorEnrichmentJobsOutput(v **ListVectorEnrichmentJobsOutput, 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 *ListVectorEnrichmentJobsOutput
if *v == nil {
sv = &ListVectorEnrichmentJobsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "VectorEnrichmentJobSummaries":
if err := awsRestjson1_deserializeDocumentVectorEnrichmentJobList(&sv.VectorEnrichmentJobSummaries, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpSearchRasterDataCollection struct {
}
func (*awsRestjson1_deserializeOpSearchRasterDataCollection) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpSearchRasterDataCollection) 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_deserializeOpErrorSearchRasterDataCollection(response, &metadata)
}
output := &SearchRasterDataCollectionOutput{}
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_deserializeOpDocumentSearchRasterDataCollectionOutput(&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_deserializeOpErrorSearchRasterDataCollection(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_deserializeOpDocumentSearchRasterDataCollectionOutput(v **SearchRasterDataCollectionOutput, 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 *SearchRasterDataCollectionOutput
if *v == nil {
sv = &SearchRasterDataCollectionOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ApproximateResultCount":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.ApproximateResultCount = ptr.Int32(int32(i64))
}
case "Items":
if err := awsRestjson1_deserializeDocumentItemSourceList(&sv.Items, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpStartEarthObservationJob struct {
}
func (*awsRestjson1_deserializeOpStartEarthObservationJob) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpStartEarthObservationJob) 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_deserializeOpErrorStartEarthObservationJob(response, &metadata)
}
output := &StartEarthObservationJobOutput{}
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_deserializeOpDocumentStartEarthObservationJobOutput(&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_deserializeOpErrorStartEarthObservationJob(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("ConflictException", errorCode):
return awsRestjson1_deserializeErrorConflictException(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("ServiceQuotaExceededException", errorCode):
return awsRestjson1_deserializeErrorServiceQuotaExceededException(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_deserializeOpDocumentStartEarthObservationJobOutput(v **StartEarthObservationJobOutput, 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 *StartEarthObservationJobOutput
if *v == nil {
sv = &StartEarthObservationJobOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value)
}
t, err := smithytime.ParseDateTime(jtv)
if err != nil {
return err
}
sv.CreationTime = ptr.Time(t)
}
case "DurationInSeconds":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.DurationInSeconds = ptr.Int32(int32(i64))
}
case "ExecutionRoleArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ExecutionRoleArn to be of type string, got %T instead", value)
}
sv.ExecutionRoleArn = ptr.String(jtv)
}
case "InputConfig":
if err := awsRestjson1_deserializeDocumentInputConfigOutput(&sv.InputConfig, value); err != nil {
return err
}
case "JobConfig":
if err := awsRestjson1_deserializeDocumentJobConfigInput(&sv.JobConfig, value); err != nil {
return err
}
case "KmsKeyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KmsKey to be of type string, got %T instead", value)
}
sv.KmsKeyId = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EarthObservationJobStatus to be of type string, got %T instead", value)
}
sv.Status = types.EarthObservationJobStatus(jtv)
}
case "Tags":
if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpStartVectorEnrichmentJob struct {
}
func (*awsRestjson1_deserializeOpStartVectorEnrichmentJob) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpStartVectorEnrichmentJob) 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_deserializeOpErrorStartVectorEnrichmentJob(response, &metadata)
}
output := &StartVectorEnrichmentJobOutput{}
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_deserializeOpDocumentStartVectorEnrichmentJobOutput(&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_deserializeOpErrorStartVectorEnrichmentJob(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("ConflictException", errorCode):
return awsRestjson1_deserializeErrorConflictException(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("ServiceQuotaExceededException", errorCode):
return awsRestjson1_deserializeErrorServiceQuotaExceededException(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_deserializeOpDocumentStartVectorEnrichmentJobOutput(v **StartVectorEnrichmentJobOutput, 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 *StartVectorEnrichmentJobOutput
if *v == nil {
sv = &StartVectorEnrichmentJobOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VectorEnrichmentJobArn to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value)
}
t, err := smithytime.ParseDateTime(jtv)
if err != nil {
return err
}
sv.CreationTime = ptr.Time(t)
}
case "DurationInSeconds":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.DurationInSeconds = ptr.Int32(int32(i64))
}
case "ExecutionRoleArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ExecutionRoleArn to be of type string, got %T instead", value)
}
sv.ExecutionRoleArn = ptr.String(jtv)
}
case "InputConfig":
if err := awsRestjson1_deserializeDocumentVectorEnrichmentJobInputConfig(&sv.InputConfig, value); err != nil {
return err
}
case "JobConfig":
if err := awsRestjson1_deserializeDocumentVectorEnrichmentJobConfig(&sv.JobConfig, value); err != nil {
return err
}
case "KmsKeyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KmsKey to be of type string, got %T instead", value)
}
sv.KmsKeyId = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VectorEnrichmentJobStatus to be of type string, got %T instead", value)
}
sv.Status = types.VectorEnrichmentJobStatus(jtv)
}
case "Tags":
if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil {
return err
}
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VectorEnrichmentJobType to be of type string, got %T instead", value)
}
sv.Type = types.VectorEnrichmentJobType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpStopEarthObservationJob struct {
}
func (*awsRestjson1_deserializeOpStopEarthObservationJob) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpStopEarthObservationJob) 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_deserializeOpErrorStopEarthObservationJob(response, &metadata)
}
output := &StopEarthObservationJobOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorStopEarthObservationJob(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("ConflictException", errorCode):
return awsRestjson1_deserializeErrorConflictException(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
}
}
type awsRestjson1_deserializeOpStopVectorEnrichmentJob struct {
}
func (*awsRestjson1_deserializeOpStopVectorEnrichmentJob) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpStopVectorEnrichmentJob) 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_deserializeOpErrorStopVectorEnrichmentJob(response, &metadata)
}
output := &StopVectorEnrichmentJobOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorStopVectorEnrichmentJob(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("ConflictException", errorCode):
return awsRestjson1_deserializeErrorConflictException(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
}
}
type awsRestjson1_deserializeOpTagResource struct {
}
func (*awsRestjson1_deserializeOpTagResource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpTagResource) 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_deserializeOpErrorTagResource(response, &metadata)
}
output := &TagResourceOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorTagResource(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
}
}
type awsRestjson1_deserializeOpUntagResource struct {
}
func (*awsRestjson1_deserializeOpUntagResource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUntagResource) 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_deserializeOpErrorUntagResource(response, &metadata)
}
output := &UntagResourceOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorUntagResource(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_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.AccessDeniedException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, 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 err
}
err := awsRestjson1_deserializeDocumentAccessDeniedException(&output, shape)
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)
return output
}
func awsRestjson1_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ConflictException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, 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 err
}
err := awsRestjson1_deserializeDocumentConflictException(&output, shape)
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)
return output
}
func awsRestjson1_deserializeErrorInternalServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.InternalServerException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, 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 err
}
err := awsRestjson1_deserializeDocumentInternalServerException(&output, shape)
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)
return output
}
func awsRestjson1_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ResourceNotFoundException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, 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 err
}
err := awsRestjson1_deserializeDocumentResourceNotFoundException(&output, shape)
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)
return output
}
func awsRestjson1_deserializeErrorServiceQuotaExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ServiceQuotaExceededException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, 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 err
}
err := awsRestjson1_deserializeDocumentServiceQuotaExceededException(&output, shape)
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)
return output
}
func awsRestjson1_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ThrottlingException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, 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 err
}
err := awsRestjson1_deserializeDocumentThrottlingException(&output, shape)
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)
return output
}
func awsRestjson1_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ValidationException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, 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 err
}
err := awsRestjson1_deserializeDocumentValidationException(&output, shape)
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)
return output
}
func awsRestjson1_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, 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.AccessDeniedException
if *v == nil {
sv = &types.AccessDeniedException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAreaOfInterest(v *types.AreaOfInterest, 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 uv types.AreaOfInterest
loop:
for key, value := range shape {
if value == nil {
continue
}
switch key {
case "AreaOfInterestGeometry":
var mv types.AreaOfInterestGeometry
if err := awsRestjson1_deserializeDocumentAreaOfInterestGeometry(&mv, value); err != nil {
return err
}
uv = &types.AreaOfInterestMemberAreaOfInterestGeometry{Value: mv}
break loop
default:
uv = &types.UnknownUnionMember{Tag: key}
break loop
}
}
*v = uv
return nil
}
func awsRestjson1_deserializeDocumentAreaOfInterestGeometry(v *types.AreaOfInterestGeometry, 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 uv types.AreaOfInterestGeometry
loop:
for key, value := range shape {
if value == nil {
continue
}
switch key {
case "MultiPolygonGeometry":
var mv types.MultiPolygonGeometryInput
destAddr := &mv
if err := awsRestjson1_deserializeDocumentMultiPolygonGeometryInput(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.AreaOfInterestGeometryMemberMultiPolygonGeometry{Value: mv}
break loop
case "PolygonGeometry":
var mv types.PolygonGeometryInput
destAddr := &mv
if err := awsRestjson1_deserializeDocumentPolygonGeometryInput(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.AreaOfInterestGeometryMemberPolygonGeometry{Value: mv}
break loop
default:
uv = &types.UnknownUnionMember{Tag: key}
break loop
}
}
*v = uv
return nil
}
func awsRestjson1_deserializeDocumentAssetsMap(v *map[string]types.AssetValue, 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 mv map[string]types.AssetValue
if *v == nil {
mv = map[string]types.AssetValue{}
} else {
mv = *v
}
for key, value := range shape {
var parsedVal types.AssetValue
mapVar := parsedVal
destAddr := &mapVar
if err := awsRestjson1_deserializeDocumentAssetValue(&destAddr, value); err != nil {
return err
}
parsedVal = *destAddr
mv[key] = parsedVal
}
*v = mv
return nil
}
func awsRestjson1_deserializeDocumentAssetValue(v **types.AssetValue, 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.AssetValue
if *v == nil {
sv = &types.AssetValue{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Href":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Href = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentBandMathConfigInput(v **types.BandMathConfigInput, 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.BandMathConfigInput
if *v == nil {
sv = &types.BandMathConfigInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CustomIndices":
if err := awsRestjson1_deserializeDocumentCustomIndicesInput(&sv.CustomIndices, value); err != nil {
return err
}
case "PredefinedIndices":
if err := awsRestjson1_deserializeDocumentStringListInput(&sv.PredefinedIndices, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentCloudMaskingConfigInput(v **types.CloudMaskingConfigInput, 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.CloudMaskingConfigInput
if *v == nil {
sv = &types.CloudMaskingConfigInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentCloudRemovalConfigInput(v **types.CloudRemovalConfigInput, 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.CloudRemovalConfigInput
if *v == nil {
sv = &types.CloudRemovalConfigInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AlgorithmName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlgorithmNameCloudRemoval to be of type string, got %T instead", value)
}
sv.AlgorithmName = types.AlgorithmNameCloudRemoval(jtv)
}
case "InterpolationValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.InterpolationValue = ptr.String(jtv)
}
case "TargetBands":
if err := awsRestjson1_deserializeDocumentStringListInput(&sv.TargetBands, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentConflictException(v **types.ConflictException, 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.ConflictException
if *v == nil {
sv = &types.ConflictException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
case "ResourceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ResourceId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentCustomIndicesInput(v **types.CustomIndicesInput, 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.CustomIndicesInput
if *v == nil {
sv = &types.CustomIndicesInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Operations":
if err := awsRestjson1_deserializeDocumentOperationsListInput(&sv.Operations, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDataCollectionsList(v *[]types.RasterDataCollectionMetadata, 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.RasterDataCollectionMetadata
if *v == nil {
cv = []types.RasterDataCollectionMetadata{}
} else {
cv = *v
}
for _, value := range shape {
var col types.RasterDataCollectionMetadata
destAddr := &col
if err := awsRestjson1_deserializeDocumentRasterDataCollectionMetadata(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentEarthObservationJobErrorDetails(v **types.EarthObservationJobErrorDetails, 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.EarthObservationJobErrorDetails
if *v == nil {
sv = &types.EarthObservationJobErrorDetails{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EarthObservationJobErrorType to be of type string, got %T instead", value)
}
sv.Type = types.EarthObservationJobErrorType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentEarthObservationJobList(v *[]types.ListEarthObservationJobOutputConfig, 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.ListEarthObservationJobOutputConfig
if *v == nil {
cv = []types.ListEarthObservationJobOutputConfig{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ListEarthObservationJobOutputConfig
destAddr := &col
if err := awsRestjson1_deserializeDocumentListEarthObservationJobOutputConfig(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentEarthObservationJobOutputBands(v *[]types.OutputBand, 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.OutputBand
if *v == nil {
cv = []types.OutputBand{}
} else {
cv = *v
}
for _, value := range shape {
var col types.OutputBand
destAddr := &col
if err := awsRestjson1_deserializeDocumentOutputBand(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentEoCloudCoverInput(v **types.EoCloudCoverInput, 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.EoCloudCoverInput
if *v == nil {
sv = &types.EoCloudCoverInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "LowerBound":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LowerBound = ptr.Float32(float32(f64))
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.LowerBound = ptr.Float32(float32(f64))
default:
return fmt.Errorf("expected Float to be a JSON Number, got %T instead", value)
}
}
case "UpperBound":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.UpperBound = ptr.Float32(float32(f64))
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.UpperBound = ptr.Float32(float32(f64))
default:
return fmt.Errorf("expected Float to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentExportErrorDetails(v **types.ExportErrorDetails, 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.ExportErrorDetails
if *v == nil {
sv = &types.ExportErrorDetails{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ExportResults":
if err := awsRestjson1_deserializeDocumentExportErrorDetailsOutput(&sv.ExportResults, value); err != nil {
return err
}
case "ExportSourceImages":
if err := awsRestjson1_deserializeDocumentExportErrorDetailsOutput(&sv.ExportSourceImages, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentExportErrorDetailsOutput(v **types.ExportErrorDetailsOutput, 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.ExportErrorDetailsOutput
if *v == nil {
sv = &types.ExportErrorDetailsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ExportErrorType to be of type string, got %T instead", value)
}
sv.Type = types.ExportErrorType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentExportS3DataInput(v **types.ExportS3DataInput, 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.ExportS3DataInput
if *v == nil {
sv = &types.ExportS3DataInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "KmsKeyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KmsKey to be of type string, got %T instead", value)
}
sv.KmsKeyId = ptr.String(jtv)
}
case "S3Uri":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected S3Uri to be of type string, got %T instead", value)
}
sv.S3Uri = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentExportVectorEnrichmentJobOutputConfig(v **types.ExportVectorEnrichmentJobOutputConfig, 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.ExportVectorEnrichmentJobOutputConfig
if *v == nil {
sv = &types.ExportVectorEnrichmentJobOutputConfig{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "S3Data":
if err := awsRestjson1_deserializeDocumentVectorEnrichmentJobS3Data(&sv.S3Data, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentFilter(v **types.Filter, 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.Filter
if *v == nil {
sv = &types.Filter{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Maximum":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.Maximum = ptr.Float32(float32(f64))
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.Maximum = ptr.Float32(float32(f64))
default:
return fmt.Errorf("expected Float to be a JSON Number, got %T instead", value)
}
}
case "Minimum":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.Minimum = ptr.Float32(float32(f64))
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.Minimum = ptr.Float32(float32(f64))
default:
return fmt.Errorf("expected Float to be a JSON Number, got %T instead", value)
}
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Type = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentFilterList(v *[]types.Filter, 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.Filter
if *v == nil {
cv = []types.Filter{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Filter
destAddr := &col
if err := awsRestjson1_deserializeDocumentFilter(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentGeometry(v **types.Geometry, 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.Geometry
if *v == nil {
sv = &types.Geometry{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Coordinates":
if err := awsRestjson1_deserializeDocumentLinearRings(&sv.Coordinates, value); err != nil {
return err
}
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Type = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentGeoMosaicConfigInput(v **types.GeoMosaicConfigInput, 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.GeoMosaicConfigInput
if *v == nil {
sv = &types.GeoMosaicConfigInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AlgorithmName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlgorithmNameGeoMosaic to be of type string, got %T instead", value)
}
sv.AlgorithmName = types.AlgorithmNameGeoMosaic(jtv)
}
case "TargetBands":
if err := awsRestjson1_deserializeDocumentStringListInput(&sv.TargetBands, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentImageSourceBandList(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 String to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentInputConfigOutput(v **types.InputConfigOutput, 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.InputConfigOutput
if *v == nil {
sv = &types.InputConfigOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "PreviousEarthObservationJobArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EarthObservationJobArn to be of type string, got %T instead", value)
}
sv.PreviousEarthObservationJobArn = ptr.String(jtv)
}
case "RasterDataCollectionQuery":
if err := awsRestjson1_deserializeDocumentRasterDataCollectionQueryOutput(&sv.RasterDataCollectionQuery, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentInternalServerException(v **types.InternalServerException, 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.InternalServerException
if *v == nil {
sv = &types.InternalServerException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
case "ResourceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ResourceId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentItemSource(v **types.ItemSource, 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.ItemSource
if *v == nil {
sv = &types.ItemSource{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Assets":
if err := awsRestjson1_deserializeDocumentAssetsMap(&sv.Assets, value); err != nil {
return err
}
case "DateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.DateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "Geometry":
if err := awsRestjson1_deserializeDocumentGeometry(&sv.Geometry, value); err != nil {
return err
}
case "Id":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Id = ptr.String(jtv)
}
case "Properties":
if err := awsRestjson1_deserializeDocumentProperties(&sv.Properties, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentItemSourceList(v *[]types.ItemSource, 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.ItemSource
if *v == nil {
cv = []types.ItemSource{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ItemSource
destAddr := &col
if err := awsRestjson1_deserializeDocumentItemSource(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentJobConfigInput(v *types.JobConfigInput, 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 uv types.JobConfigInput
loop:
for key, value := range shape {
if value == nil {
continue
}
switch key {
case "BandMathConfig":
var mv types.BandMathConfigInput
destAddr := &mv
if err := awsRestjson1_deserializeDocumentBandMathConfigInput(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.JobConfigInputMemberBandMathConfig{Value: mv}
break loop
case "CloudMaskingConfig":
var mv types.CloudMaskingConfigInput
destAddr := &mv
if err := awsRestjson1_deserializeDocumentCloudMaskingConfigInput(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.JobConfigInputMemberCloudMaskingConfig{Value: mv}
break loop
case "CloudRemovalConfig":
var mv types.CloudRemovalConfigInput
destAddr := &mv
if err := awsRestjson1_deserializeDocumentCloudRemovalConfigInput(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.JobConfigInputMemberCloudRemovalConfig{Value: mv}
break loop
case "GeoMosaicConfig":
var mv types.GeoMosaicConfigInput
destAddr := &mv
if err := awsRestjson1_deserializeDocumentGeoMosaicConfigInput(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.JobConfigInputMemberGeoMosaicConfig{Value: mv}
break loop
case "LandCoverSegmentationConfig":
var mv types.LandCoverSegmentationConfigInput
destAddr := &mv
if err := awsRestjson1_deserializeDocumentLandCoverSegmentationConfigInput(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.JobConfigInputMemberLandCoverSegmentationConfig{Value: mv}
break loop
case "ResamplingConfig":
var mv types.ResamplingConfigInput
destAddr := &mv
if err := awsRestjson1_deserializeDocumentResamplingConfigInput(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.JobConfigInputMemberResamplingConfig{Value: mv}
break loop
case "StackConfig":
var mv types.StackConfigInput
destAddr := &mv
if err := awsRestjson1_deserializeDocumentStackConfigInput(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.JobConfigInputMemberStackConfig{Value: mv}
break loop
case "TemporalStatisticsConfig":
var mv types.TemporalStatisticsConfigInput
destAddr := &mv
if err := awsRestjson1_deserializeDocumentTemporalStatisticsConfigInput(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.JobConfigInputMemberTemporalStatisticsConfig{Value: mv}
break loop
case "ZonalStatisticsConfig":
var mv types.ZonalStatisticsConfigInput
destAddr := &mv
if err := awsRestjson1_deserializeDocumentZonalStatisticsConfigInput(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.JobConfigInputMemberZonalStatisticsConfig{Value: mv}
break loop
default:
uv = &types.UnknownUnionMember{Tag: key}
break loop
}
}
*v = uv
return nil
}
func awsRestjson1_deserializeDocumentLandCoverSegmentationConfigInput(v **types.LandCoverSegmentationConfigInput, 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.LandCoverSegmentationConfigInput
if *v == nil {
sv = &types.LandCoverSegmentationConfigInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentLandsatCloudCoverLandInput(v **types.LandsatCloudCoverLandInput, 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.LandsatCloudCoverLandInput
if *v == nil {
sv = &types.LandsatCloudCoverLandInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "LowerBound":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LowerBound = ptr.Float32(float32(f64))
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.LowerBound = ptr.Float32(float32(f64))
default:
return fmt.Errorf("expected Float to be a JSON Number, got %T instead", value)
}
}
case "UpperBound":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.UpperBound = ptr.Float32(float32(f64))
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.UpperBound = ptr.Float32(float32(f64))
default:
return fmt.Errorf("expected Float to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentLinearRing(v *[][]float64, 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 [][]float64
if *v == nil {
cv = [][]float64{}
} else {
cv = *v
}
for _, value := range shape {
var col []float64
if err := awsRestjson1_deserializeDocumentPosition(&col, value); err != nil {
return err
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentLinearRings(v *[][][]float64, 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 [][][]float64
if *v == nil {
cv = [][][]float64{}
} else {
cv = *v
}
for _, value := range shape {
var col [][]float64
if err := awsRestjson1_deserializeDocumentLinearRing(&col, value); err != nil {
return err
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentLinearRingsList(v *[][][][]float64, 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 [][][][]float64
if *v == nil {
cv = [][][][]float64{}
} else {
cv = *v
}
for _, value := range shape {
var col [][][]float64
if err := awsRestjson1_deserializeDocumentLinearRings(&col, value); err != nil {
return err
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentListEarthObservationJobOutputConfig(v **types.ListEarthObservationJobOutputConfig, 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.ListEarthObservationJobOutputConfig
if *v == nil {
sv = &types.ListEarthObservationJobOutputConfig{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value)
}
t, err := smithytime.ParseDateTime(jtv)
if err != nil {
return err
}
sv.CreationTime = ptr.Time(t)
}
case "DurationInSeconds":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.DurationInSeconds = ptr.Int32(int32(i64))
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "OperationType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.OperationType = ptr.String(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EarthObservationJobStatus to be of type string, got %T instead", value)
}
sv.Status = types.EarthObservationJobStatus(jtv)
}
case "Tags":
if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentListVectorEnrichmentJobOutputConfig(v **types.ListVectorEnrichmentJobOutputConfig, 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.ListVectorEnrichmentJobOutputConfig
if *v == nil {
sv = &types.ListVectorEnrichmentJobOutputConfig{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VectorEnrichmentJobArn to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value)
}
t, err := smithytime.ParseDateTime(jtv)
if err != nil {
return err
}
sv.CreationTime = ptr.Time(t)
}
case "DurationInSeconds":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.DurationInSeconds = ptr.Int32(int32(i64))
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VectorEnrichmentJobStatus to be of type string, got %T instead", value)
}
sv.Status = types.VectorEnrichmentJobStatus(jtv)
}
case "Tags":
if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil {
return err
}
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VectorEnrichmentJobType to be of type string, got %T instead", value)
}
sv.Type = types.VectorEnrichmentJobType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentMapMatchingConfig(v **types.MapMatchingConfig, 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.MapMatchingConfig
if *v == nil {
sv = &types.MapMatchingConfig{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "IdAttributeName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.IdAttributeName = ptr.String(jtv)
}
case "TimestampAttributeName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.TimestampAttributeName = ptr.String(jtv)
}
case "XAttributeName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.XAttributeName = ptr.String(jtv)
}
case "YAttributeName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.YAttributeName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentMultiPolygonGeometryInput(v **types.MultiPolygonGeometryInput, 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.MultiPolygonGeometryInput
if *v == nil {
sv = &types.MultiPolygonGeometryInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Coordinates":
if err := awsRestjson1_deserializeDocumentLinearRingsList(&sv.Coordinates, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentOperation(v **types.Operation, 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.Operation
if *v == nil {
sv = &types.Operation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Equation":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Equation = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "OutputType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected OutputType to be of type string, got %T instead", value)
}
sv.OutputType = types.OutputType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentOperationsListInput(v *[]types.Operation, 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.Operation
if *v == nil {
cv = []types.Operation{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Operation
destAddr := &col
if err := awsRestjson1_deserializeDocumentOperation(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentOutputBand(v **types.OutputBand, 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.OutputBand
if *v == nil {
sv = &types.OutputBand{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "BandName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.BandName = ptr.String(jtv)
}
case "OutputDataType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected OutputType to be of type string, got %T instead", value)
}
sv.OutputDataType = types.OutputType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentOutputConfigInput(v **types.OutputConfigInput, 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.OutputConfigInput
if *v == nil {
sv = &types.OutputConfigInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "S3Data":
if err := awsRestjson1_deserializeDocumentExportS3DataInput(&sv.S3Data, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentOutputResolutionResamplingInput(v **types.OutputResolutionResamplingInput, 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.OutputResolutionResamplingInput
if *v == nil {
sv = &types.OutputResolutionResamplingInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "UserDefined":
if err := awsRestjson1_deserializeDocumentUserDefined(&sv.UserDefined, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentOutputResolutionStackInput(v **types.OutputResolutionStackInput, 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.OutputResolutionStackInput
if *v == nil {
sv = &types.OutputResolutionStackInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Predefined":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PredefinedResolution to be of type string, got %T instead", value)
}
sv.Predefined = types.PredefinedResolution(jtv)
}
case "UserDefined":
if err := awsRestjson1_deserializeDocumentUserDefined(&sv.UserDefined, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPlatformInput(v **types.PlatformInput, 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.PlatformInput
if *v == nil {
sv = &types.PlatformInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ComparisonOperator":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ComparisonOperator to be of type string, got %T instead", value)
}
sv.ComparisonOperator = types.ComparisonOperator(jtv)
}
case "Value":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Value = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPolygonGeometryInput(v **types.PolygonGeometryInput, 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.PolygonGeometryInput
if *v == nil {
sv = &types.PolygonGeometryInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Coordinates":
if err := awsRestjson1_deserializeDocumentLinearRings(&sv.Coordinates, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPosition(v *[]float64, 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 []float64
if *v == nil {
cv = []float64{}
} else {
cv = *v
}
for _, value := range shape {
var col float64
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
col = f64
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
col = f64
default:
return fmt.Errorf("expected Double to be a JSON Number, got %T instead", value)
}
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentProperties(v **types.Properties, 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.Properties
if *v == nil {
sv = &types.Properties{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "EoCloudCover":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.EoCloudCover = ptr.Float32(float32(f64))
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.EoCloudCover = ptr.Float32(float32(f64))
default:
return fmt.Errorf("expected Float to be a JSON Number, got %T instead", value)
}
}
case "LandsatCloudCoverLand":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LandsatCloudCoverLand = ptr.Float32(float32(f64))
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.LandsatCloudCoverLand = ptr.Float32(float32(f64))
default:
return fmt.Errorf("expected Float to be a JSON Number, got %T instead", value)
}
}
case "Platform":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Platform = ptr.String(jtv)
}
case "ViewOffNadir":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.ViewOffNadir = ptr.Float32(float32(f64))
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.ViewOffNadir = ptr.Float32(float32(f64))
default:
return fmt.Errorf("expected Float to be a JSON Number, got %T instead", value)
}
}
case "ViewSunAzimuth":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.ViewSunAzimuth = ptr.Float32(float32(f64))
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.ViewSunAzimuth = ptr.Float32(float32(f64))
default:
return fmt.Errorf("expected Float to be a JSON Number, got %T instead", value)
}
}
case "ViewSunElevation":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.ViewSunElevation = ptr.Float32(float32(f64))
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.ViewSunElevation = ptr.Float32(float32(f64))
default:
return fmt.Errorf("expected Float to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentProperty(v *types.Property, 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 uv types.Property
loop:
for key, value := range shape {
if value == nil {
continue
}
switch key {
case "EoCloudCover":
var mv types.EoCloudCoverInput
destAddr := &mv
if err := awsRestjson1_deserializeDocumentEoCloudCoverInput(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.PropertyMemberEoCloudCover{Value: mv}
break loop
case "LandsatCloudCoverLand":
var mv types.LandsatCloudCoverLandInput
destAddr := &mv
if err := awsRestjson1_deserializeDocumentLandsatCloudCoverLandInput(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.PropertyMemberLandsatCloudCoverLand{Value: mv}
break loop
case "Platform":
var mv types.PlatformInput
destAddr := &mv
if err := awsRestjson1_deserializeDocumentPlatformInput(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.PropertyMemberPlatform{Value: mv}
break loop
case "ViewOffNadir":
var mv types.ViewOffNadirInput
destAddr := &mv
if err := awsRestjson1_deserializeDocumentViewOffNadirInput(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.PropertyMemberViewOffNadir{Value: mv}
break loop
case "ViewSunAzimuth":
var mv types.ViewSunAzimuthInput
destAddr := &mv
if err := awsRestjson1_deserializeDocumentViewSunAzimuthInput(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.PropertyMemberViewSunAzimuth{Value: mv}
break loop
case "ViewSunElevation":
var mv types.ViewSunElevationInput
destAddr := &mv
if err := awsRestjson1_deserializeDocumentViewSunElevationInput(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.PropertyMemberViewSunElevation{Value: mv}
break loop
default:
uv = &types.UnknownUnionMember{Tag: key}
break loop
}
}
*v = uv
return nil
}
func awsRestjson1_deserializeDocumentPropertyFilter(v **types.PropertyFilter, 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.PropertyFilter
if *v == nil {
sv = &types.PropertyFilter{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Property":
if err := awsRestjson1_deserializeDocumentProperty(&sv.Property, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPropertyFilters(v **types.PropertyFilters, 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.PropertyFilters
if *v == nil {
sv = &types.PropertyFilters{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "LogicalOperator":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LogicalOperator to be of type string, got %T instead", value)
}
sv.LogicalOperator = types.LogicalOperator(jtv)
}
case "Properties":
if err := awsRestjson1_deserializeDocumentPropertyFiltersList(&sv.Properties, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPropertyFiltersList(v *[]types.PropertyFilter, 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.PropertyFilter
if *v == nil {
cv = []types.PropertyFilter{}
} else {
cv = *v
}
for _, value := range shape {
var col types.PropertyFilter
destAddr := &col
if err := awsRestjson1_deserializeDocumentPropertyFilter(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentRasterDataCollectionMetadata(v **types.RasterDataCollectionMetadata, 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.RasterDataCollectionMetadata
if *v == nil {
sv = &types.RasterDataCollectionMetadata{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DataCollectionArn to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "DescriptionPageUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.DescriptionPageUrl = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "SupportedFilters":
if err := awsRestjson1_deserializeDocumentFilterList(&sv.SupportedFilters, value); err != nil {
return err
}
case "Tags":
if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil {
return err
}
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DataCollectionType to be of type string, got %T instead", value)
}
sv.Type = types.DataCollectionType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentRasterDataCollectionQueryOutput(v **types.RasterDataCollectionQueryOutput, 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.RasterDataCollectionQueryOutput
if *v == nil {
sv = &types.RasterDataCollectionQueryOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AreaOfInterest":
if err := awsRestjson1_deserializeDocumentAreaOfInterest(&sv.AreaOfInterest, value); err != nil {
return err
}
case "PropertyFilters":
if err := awsRestjson1_deserializeDocumentPropertyFilters(&sv.PropertyFilters, value); err != nil {
return err
}
case "RasterDataCollectionArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DataCollectionArn to be of type string, got %T instead", value)
}
sv.RasterDataCollectionArn = ptr.String(jtv)
}
case "RasterDataCollectionName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.RasterDataCollectionName = ptr.String(jtv)
}
case "TimeRangeFilter":
if err := awsRestjson1_deserializeDocumentTimeRangeFilterOutput(&sv.TimeRangeFilter, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResamplingConfigInput(v **types.ResamplingConfigInput, 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.ResamplingConfigInput
if *v == nil {
sv = &types.ResamplingConfigInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AlgorithmName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlgorithmNameResampling to be of type string, got %T instead", value)
}
sv.AlgorithmName = types.AlgorithmNameResampling(jtv)
}
case "OutputResolution":
if err := awsRestjson1_deserializeDocumentOutputResolutionResamplingInput(&sv.OutputResolution, value); err != nil {
return err
}
case "TargetBands":
if err := awsRestjson1_deserializeDocumentStringListInput(&sv.TargetBands, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, 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.ResourceNotFoundException
if *v == nil {
sv = &types.ResourceNotFoundException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
case "ResourceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ResourceId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentReverseGeocodingConfig(v **types.ReverseGeocodingConfig, 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.ReverseGeocodingConfig
if *v == nil {
sv = &types.ReverseGeocodingConfig{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "XAttributeName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.XAttributeName = ptr.String(jtv)
}
case "YAttributeName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.YAttributeName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentServiceQuotaExceededException(v **types.ServiceQuotaExceededException, 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.ServiceQuotaExceededException
if *v == nil {
sv = &types.ServiceQuotaExceededException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
case "ResourceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ResourceId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentStackConfigInput(v **types.StackConfigInput, 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.StackConfigInput
if *v == nil {
sv = &types.StackConfigInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "OutputResolution":
if err := awsRestjson1_deserializeDocumentOutputResolutionStackInput(&sv.OutputResolution, value); err != nil {
return err
}
case "TargetBands":
if err := awsRestjson1_deserializeDocumentStringListInput(&sv.TargetBands, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentStringListInput(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 String to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentTags(v *map[string]string, 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 mv map[string]string
if *v == nil {
mv = map[string]string{}
} else {
mv = *v
}
for key, value := range shape {
var parsedVal string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
parsedVal = jtv
}
mv[key] = parsedVal
}
*v = mv
return nil
}
func awsRestjson1_deserializeDocumentTemporalStatisticsConfigInput(v **types.TemporalStatisticsConfigInput, 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.TemporalStatisticsConfigInput
if *v == nil {
sv = &types.TemporalStatisticsConfigInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "GroupBy":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected GroupBy to be of type string, got %T instead", value)
}
sv.GroupBy = types.GroupBy(jtv)
}
case "Statistics":
if err := awsRestjson1_deserializeDocumentTemporalStatisticsListInput(&sv.Statistics, value); err != nil {
return err
}
case "TargetBands":
if err := awsRestjson1_deserializeDocumentStringListInput(&sv.TargetBands, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTemporalStatisticsListInput(v *[]types.TemporalStatistics, 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.TemporalStatistics
if *v == nil {
cv = []types.TemporalStatistics{}
} else {
cv = *v
}
for _, value := range shape {
var col types.TemporalStatistics
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TemporalStatistics to be of type string, got %T instead", value)
}
col = types.TemporalStatistics(jtv)
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentThrottlingException(v **types.ThrottlingException, 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.ThrottlingException
if *v == nil {
sv = &types.ThrottlingException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
case "ResourceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ResourceId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTimeRangeFilterOutput(v **types.TimeRangeFilterOutput, 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.TimeRangeFilterOutput
if *v == nil {
sv = &types.TimeRangeFilterOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "EndTime":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value)
}
t, err := smithytime.ParseDateTime(jtv)
if err != nil {
return err
}
sv.EndTime = ptr.Time(t)
}
case "StartTime":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Timestamp to be of type string, got %T instead", value)
}
t, err := smithytime.ParseDateTime(jtv)
if err != nil {
return err
}
sv.StartTime = ptr.Time(t)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentUserDefined(v **types.UserDefined, 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.UserDefined
if *v == nil {
sv = &types.UserDefined{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Unit":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Unit to be of type string, got %T instead", value)
}
sv.Unit = types.Unit(jtv)
}
case "Value":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.Value = ptr.Float32(float32(f64))
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.Value = ptr.Float32(float32(f64))
default:
return fmt.Errorf("expected Float to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentValidationException(v **types.ValidationException, 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.ValidationException
if *v == nil {
sv = &types.ValidationException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
case "ResourceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ResourceId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentVectorEnrichmentJobConfig(v *types.VectorEnrichmentJobConfig, 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 uv types.VectorEnrichmentJobConfig
loop:
for key, value := range shape {
if value == nil {
continue
}
switch key {
case "MapMatchingConfig":
var mv types.MapMatchingConfig
destAddr := &mv
if err := awsRestjson1_deserializeDocumentMapMatchingConfig(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.VectorEnrichmentJobConfigMemberMapMatchingConfig{Value: mv}
break loop
case "ReverseGeocodingConfig":
var mv types.ReverseGeocodingConfig
destAddr := &mv
if err := awsRestjson1_deserializeDocumentReverseGeocodingConfig(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.VectorEnrichmentJobConfigMemberReverseGeocodingConfig{Value: mv}
break loop
default:
uv = &types.UnknownUnionMember{Tag: key}
break loop
}
}
*v = uv
return nil
}
func awsRestjson1_deserializeDocumentVectorEnrichmentJobDataSourceConfigInput(v *types.VectorEnrichmentJobDataSourceConfigInput, 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 uv types.VectorEnrichmentJobDataSourceConfigInput
loop:
for key, value := range shape {
if value == nil {
continue
}
switch key {
case "S3Data":
var mv types.VectorEnrichmentJobS3Data
destAddr := &mv
if err := awsRestjson1_deserializeDocumentVectorEnrichmentJobS3Data(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.VectorEnrichmentJobDataSourceConfigInputMemberS3Data{Value: mv}
break loop
default:
uv = &types.UnknownUnionMember{Tag: key}
break loop
}
}
*v = uv
return nil
}
func awsRestjson1_deserializeDocumentVectorEnrichmentJobErrorDetails(v **types.VectorEnrichmentJobErrorDetails, 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.VectorEnrichmentJobErrorDetails
if *v == nil {
sv = &types.VectorEnrichmentJobErrorDetails{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ErrorMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ErrorMessage = ptr.String(jtv)
}
case "ErrorType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VectorEnrichmentJobErrorType to be of type string, got %T instead", value)
}
sv.ErrorType = types.VectorEnrichmentJobErrorType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentVectorEnrichmentJobExportErrorDetails(v **types.VectorEnrichmentJobExportErrorDetails, 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.VectorEnrichmentJobExportErrorDetails
if *v == nil {
sv = &types.VectorEnrichmentJobExportErrorDetails{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VectorEnrichmentJobExportErrorType to be of type string, got %T instead", value)
}
sv.Type = types.VectorEnrichmentJobExportErrorType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentVectorEnrichmentJobInputConfig(v **types.VectorEnrichmentJobInputConfig, 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.VectorEnrichmentJobInputConfig
if *v == nil {
sv = &types.VectorEnrichmentJobInputConfig{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "DataSourceConfig":
if err := awsRestjson1_deserializeDocumentVectorEnrichmentJobDataSourceConfigInput(&sv.DataSourceConfig, value); err != nil {
return err
}
case "DocumentType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VectorEnrichmentJobDocumentType to be of type string, got %T instead", value)
}
sv.DocumentType = types.VectorEnrichmentJobDocumentType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentVectorEnrichmentJobList(v *[]types.ListVectorEnrichmentJobOutputConfig, 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.ListVectorEnrichmentJobOutputConfig
if *v == nil {
cv = []types.ListVectorEnrichmentJobOutputConfig{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ListVectorEnrichmentJobOutputConfig
destAddr := &col
if err := awsRestjson1_deserializeDocumentListVectorEnrichmentJobOutputConfig(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentVectorEnrichmentJobS3Data(v **types.VectorEnrichmentJobS3Data, 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.VectorEnrichmentJobS3Data
if *v == nil {
sv = &types.VectorEnrichmentJobS3Data{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "KmsKeyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KmsKey to be of type string, got %T instead", value)
}
sv.KmsKeyId = ptr.String(jtv)
}
case "S3Uri":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected S3Uri to be of type string, got %T instead", value)
}
sv.S3Uri = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentViewOffNadirInput(v **types.ViewOffNadirInput, 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.ViewOffNadirInput
if *v == nil {
sv = &types.ViewOffNadirInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "LowerBound":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LowerBound = ptr.Float32(float32(f64))
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.LowerBound = ptr.Float32(float32(f64))
default:
return fmt.Errorf("expected Float to be a JSON Number, got %T instead", value)
}
}
case "UpperBound":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.UpperBound = ptr.Float32(float32(f64))
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.UpperBound = ptr.Float32(float32(f64))
default:
return fmt.Errorf("expected Float to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentViewSunAzimuthInput(v **types.ViewSunAzimuthInput, 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.ViewSunAzimuthInput
if *v == nil {
sv = &types.ViewSunAzimuthInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "LowerBound":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LowerBound = ptr.Float32(float32(f64))
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.LowerBound = ptr.Float32(float32(f64))
default:
return fmt.Errorf("expected Float to be a JSON Number, got %T instead", value)
}
}
case "UpperBound":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.UpperBound = ptr.Float32(float32(f64))
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.UpperBound = ptr.Float32(float32(f64))
default:
return fmt.Errorf("expected Float to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentViewSunElevationInput(v **types.ViewSunElevationInput, 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.ViewSunElevationInput
if *v == nil {
sv = &types.ViewSunElevationInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "LowerBound":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LowerBound = ptr.Float32(float32(f64))
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.LowerBound = ptr.Float32(float32(f64))
default:
return fmt.Errorf("expected Float to be a JSON Number, got %T instead", value)
}
}
case "UpperBound":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.UpperBound = ptr.Float32(float32(f64))
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.UpperBound = ptr.Float32(float32(f64))
default:
return fmt.Errorf("expected Float to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentZonalStatisticsConfigInput(v **types.ZonalStatisticsConfigInput, 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.ZonalStatisticsConfigInput
if *v == nil {
sv = &types.ZonalStatisticsConfigInput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Statistics":
if err := awsRestjson1_deserializeDocumentZonalStatisticsListInput(&sv.Statistics, value); err != nil {
return err
}
case "TargetBands":
if err := awsRestjson1_deserializeDocumentStringListInput(&sv.TargetBands, value); err != nil {
return err
}
case "ZoneS3Path":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected S3Uri to be of type string, got %T instead", value)
}
sv.ZoneS3Path = ptr.String(jtv)
}
case "ZoneS3PathKmsKeyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KmsKey to be of type string, got %T instead", value)
}
sv.ZoneS3PathKmsKeyId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentZonalStatisticsListInput(v *[]types.ZonalStatistics, 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.ZonalStatistics
if *v == nil {
cv = []types.ZonalStatistics{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ZonalStatistics
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ZonalStatistics to be of type string, got %T instead", value)
}
col = types.ZonalStatistics(jtv)
}
cv = append(cv, col)
}
*v = cv
return nil
}
| 7,737 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package sagemakergeospatial provides the API client, operations, and parameter
// types for Amazon SageMaker geospatial capabilities.
//
// Provides APIs for creating and managing SageMaker geospatial resources.
package sagemakergeospatial
| 8 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
import (
"context"
"errors"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
internalendpoints "github.com/aws/aws-sdk-go-v2/service/sagemakergeospatial/internal/endpoints"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net/url"
"strings"
)
// EndpointResolverOptions is the service endpoint resolver options
type EndpointResolverOptions = internalendpoints.Options
// EndpointResolver interface for resolving service endpoints.
type EndpointResolver interface {
ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
}
var _ EndpointResolver = &internalendpoints.Resolver{}
// NewDefaultEndpointResolver constructs a new service endpoint resolver
func NewDefaultEndpointResolver() *internalendpoints.Resolver {
return internalendpoints.New()
}
// 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.
type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)
func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
return fn(region, options)
}
func resolveDefaultEndpointConfiguration(o *Options) {
if o.EndpointResolver != nil {
return
}
o.EndpointResolver = NewDefaultEndpointResolver()
}
// 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.
func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver {
e := aws.Endpoint{URL: url, Source: aws.EndpointSourceCustom}
for _, fn := range optFns {
fn(&e)
}
return EndpointResolverFunc(
func(region string, options EndpointResolverOptions) (aws.Endpoint, error) {
if len(e.SigningRegion) == 0 {
e.SigningRegion = region
}
return e, nil
},
)
}
type ResolveEndpoint struct {
Resolver EndpointResolver
Options EndpointResolverOptions
}
func (*ResolveEndpoint) ID() string {
return "ResolveEndpoint"
}
func (m *ResolveEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
if m.Resolver == nil {
return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
}
eo := m.Options
eo.Logger = middleware.GetLogger(ctx)
var endpoint aws.Endpoint
endpoint, err = m.Resolver.ResolveEndpoint(awsmiddleware.GetRegion(ctx), eo)
if err != nil {
return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err)
}
req.URL, err = url.Parse(endpoint.URL)
if err != nil {
return out, metadata, fmt.Errorf("failed to parse endpoint URL: %w", err)
}
if len(awsmiddleware.GetSigningName(ctx)) == 0 {
signingName := endpoint.SigningName
if len(signingName) == 0 {
signingName = "sagemaker-geospatial"
}
ctx = awsmiddleware.SetSigningName(ctx, signingName)
}
ctx = awsmiddleware.SetEndpointSource(ctx, endpoint.Source)
ctx = smithyhttp.SetHostnameImmutable(ctx, endpoint.HostnameImmutable)
ctx = awsmiddleware.SetSigningRegion(ctx, endpoint.SigningRegion)
ctx = awsmiddleware.SetPartitionID(ctx, endpoint.PartitionID)
return next.HandleSerialize(ctx, in)
}
func addResolveEndpointMiddleware(stack *middleware.Stack, o Options) error {
return stack.Serialize.Insert(&ResolveEndpoint{
Resolver: o.EndpointResolver,
Options: o.EndpointOptions,
}, "OperationSerializer", middleware.Before)
}
func removeResolveEndpointMiddleware(stack *middleware.Stack) error {
_, err := stack.Serialize.Remove((&ResolveEndpoint{}).ID())
return err
}
type wrappedEndpointResolver struct {
awsResolver aws.EndpointResolverWithOptions
resolver EndpointResolver
}
func (w *wrappedEndpointResolver) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
if w.awsResolver == nil {
goto fallback
}
endpoint, err = w.awsResolver.ResolveEndpoint(ServiceID, region, options)
if err == nil {
return endpoint, nil
}
if nf := (&aws.EndpointNotFoundError{}); !errors.As(err, &nf) {
return endpoint, err
}
fallback:
if w.resolver == nil {
return endpoint, fmt.Errorf("default endpoint resolver provided was nil")
}
return w.resolver.ResolveEndpoint(region, options)
}
type awsEndpointResolverAdaptor func(service, region string) (aws.Endpoint, error)
func (a awsEndpointResolverAdaptor) ResolveEndpoint(service, region string, options ...interface{}) (aws.Endpoint, error) {
return a(service, region)
}
var _ aws.EndpointResolverWithOptions = awsEndpointResolverAdaptor(nil)
// withEndpointResolver returns an EndpointResolver that first delegates endpoint resolution to the awsResolver.
// If awsResolver returns aws.EndpointNotFoundError error, the resolver will use the the provided
// fallbackResolver for resolution.
//
// fallbackResolver must not be nil
func withEndpointResolver(awsResolver aws.EndpointResolver, awsResolverWithOptions aws.EndpointResolverWithOptions, fallbackResolver EndpointResolver) EndpointResolver {
var resolver aws.EndpointResolverWithOptions
if awsResolverWithOptions != nil {
resolver = awsResolverWithOptions
} else if awsResolver != nil {
resolver = awsEndpointResolverAdaptor(awsResolver.ResolveEndpoint)
}
return &wrappedEndpointResolver{
awsResolver: resolver,
resolver: fallbackResolver,
}
}
func finalizeClientEndpointResolverOptions(options *Options) {
options.EndpointOptions.LogDeprecated = options.ClientLogMode.IsDeprecatedUsage()
if len(options.EndpointOptions.ResolvedRegion) == 0 {
const fipsInfix = "-fips-"
const fipsPrefix = "fips-"
const fipsSuffix = "-fips"
if strings.Contains(options.Region, fipsInfix) ||
strings.Contains(options.Region, fipsPrefix) ||
strings.Contains(options.Region, fipsSuffix) {
options.EndpointOptions.ResolvedRegion = strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(
options.Region, fipsInfix, "-"), fipsPrefix, ""), fipsSuffix, "")
options.EndpointOptions.UseFIPSEndpoint = aws.FIPSEndpointStateEnabled
}
}
}
| 201 |
aws-sdk-go-v2 | aws | Go | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT.
package sagemakergeospatial
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.3.2"
| 7 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
import (
"bytes"
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/sagemakergeospatial/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/encoding/httpbinding"
smithyjson "github.com/aws/smithy-go/encoding/json"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
"math"
)
type awsRestjson1_serializeOpDeleteEarthObservationJob struct {
}
func (*awsRestjson1_serializeOpDeleteEarthObservationJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteEarthObservationJob) 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.(*DeleteEarthObservationJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/earth-observation-jobs/{Arn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsDeleteEarthObservationJobInput(input, restEncoder); 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_serializeOpHttpBindingsDeleteEarthObservationJobInput(v *DeleteEarthObservationJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Arn == nil || len(*v.Arn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Arn must not be empty")}
}
if v.Arn != nil {
if err := encoder.SetURI("Arn").String(*v.Arn); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteVectorEnrichmentJob struct {
}
func (*awsRestjson1_serializeOpDeleteVectorEnrichmentJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteVectorEnrichmentJob) 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.(*DeleteVectorEnrichmentJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/vector-enrichment-jobs/{Arn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsDeleteVectorEnrichmentJobInput(input, restEncoder); 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_serializeOpHttpBindingsDeleteVectorEnrichmentJobInput(v *DeleteVectorEnrichmentJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Arn == nil || len(*v.Arn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Arn must not be empty")}
}
if v.Arn != nil {
if err := encoder.SetURI("Arn").String(*v.Arn); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpExportEarthObservationJob struct {
}
func (*awsRestjson1_serializeOpExportEarthObservationJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpExportEarthObservationJob) 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.(*ExportEarthObservationJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/export-earth-observation-job")
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_serializeOpDocumentExportEarthObservationJobInput(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_serializeOpHttpBindingsExportEarthObservationJobInput(v *ExportEarthObservationJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentExportEarthObservationJobInput(v *ExportEarthObservationJobInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Arn != nil {
ok := object.Key("Arn")
ok.String(*v.Arn)
}
if v.ClientToken != nil {
ok := object.Key("ClientToken")
ok.String(*v.ClientToken)
}
if v.ExecutionRoleArn != nil {
ok := object.Key("ExecutionRoleArn")
ok.String(*v.ExecutionRoleArn)
}
if v.ExportSourceImages != nil {
ok := object.Key("ExportSourceImages")
ok.Boolean(*v.ExportSourceImages)
}
if v.OutputConfig != nil {
ok := object.Key("OutputConfig")
if err := awsRestjson1_serializeDocumentOutputConfigInput(v.OutputConfig, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpExportVectorEnrichmentJob struct {
}
func (*awsRestjson1_serializeOpExportVectorEnrichmentJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpExportVectorEnrichmentJob) 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.(*ExportVectorEnrichmentJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/export-vector-enrichment-jobs")
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_serializeOpDocumentExportVectorEnrichmentJobInput(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_serializeOpHttpBindingsExportVectorEnrichmentJobInput(v *ExportVectorEnrichmentJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentExportVectorEnrichmentJobInput(v *ExportVectorEnrichmentJobInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Arn != nil {
ok := object.Key("Arn")
ok.String(*v.Arn)
}
if v.ClientToken != nil {
ok := object.Key("ClientToken")
ok.String(*v.ClientToken)
}
if v.ExecutionRoleArn != nil {
ok := object.Key("ExecutionRoleArn")
ok.String(*v.ExecutionRoleArn)
}
if v.OutputConfig != nil {
ok := object.Key("OutputConfig")
if err := awsRestjson1_serializeDocumentExportVectorEnrichmentJobOutputConfig(v.OutputConfig, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetEarthObservationJob struct {
}
func (*awsRestjson1_serializeOpGetEarthObservationJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetEarthObservationJob) 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.(*GetEarthObservationJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/earth-observation-jobs/{Arn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetEarthObservationJobInput(input, restEncoder); 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_serializeOpHttpBindingsGetEarthObservationJobInput(v *GetEarthObservationJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Arn == nil || len(*v.Arn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Arn must not be empty")}
}
if v.Arn != nil {
if err := encoder.SetURI("Arn").String(*v.Arn); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetRasterDataCollection struct {
}
func (*awsRestjson1_serializeOpGetRasterDataCollection) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetRasterDataCollection) 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.(*GetRasterDataCollectionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/raster-data-collection/{Arn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetRasterDataCollectionInput(input, restEncoder); 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_serializeOpHttpBindingsGetRasterDataCollectionInput(v *GetRasterDataCollectionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Arn == nil || len(*v.Arn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Arn must not be empty")}
}
if v.Arn != nil {
if err := encoder.SetURI("Arn").String(*v.Arn); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetTile struct {
}
func (*awsRestjson1_serializeOpGetTile) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetTile) 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.(*GetTileInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/tile/{z}/{x}/{y}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetTileInput(input, restEncoder); 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_serializeOpHttpBindingsGetTileInput(v *GetTileInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Arn != nil {
encoder.SetQuery("Arn").String(*v.Arn)
}
if v.ExecutionRoleArn != nil {
encoder.SetQuery("ExecutionRoleArn").String(*v.ExecutionRoleArn)
}
if v.ImageAssets != nil {
for i := range v.ImageAssets {
encoder.AddQuery("ImageAssets").String(v.ImageAssets[i])
}
}
if v.ImageMask != nil {
encoder.SetQuery("ImageMask").Boolean(*v.ImageMask)
}
if len(v.OutputDataType) > 0 {
encoder.SetQuery("OutputDataType").String(string(v.OutputDataType))
}
if v.OutputFormat != nil {
encoder.SetQuery("OutputFormat").String(*v.OutputFormat)
}
if v.PropertyFilters != nil {
encoder.SetQuery("PropertyFilters").String(*v.PropertyFilters)
}
if len(v.Target) > 0 {
encoder.SetQuery("Target").String(string(v.Target))
}
if v.TimeRangeFilter != nil {
encoder.SetQuery("TimeRangeFilter").String(*v.TimeRangeFilter)
}
if v.X == nil {
return &smithy.SerializationError{Err: fmt.Errorf("input member x must not be empty")}
}
if v.X != nil {
if err := encoder.SetURI("x").Integer(*v.X); err != nil {
return err
}
}
if v.Y == nil {
return &smithy.SerializationError{Err: fmt.Errorf("input member y must not be empty")}
}
if v.Y != nil {
if err := encoder.SetURI("y").Integer(*v.Y); err != nil {
return err
}
}
if v.Z == nil {
return &smithy.SerializationError{Err: fmt.Errorf("input member z must not be empty")}
}
if v.Z != nil {
if err := encoder.SetURI("z").Integer(*v.Z); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetVectorEnrichmentJob struct {
}
func (*awsRestjson1_serializeOpGetVectorEnrichmentJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetVectorEnrichmentJob) 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.(*GetVectorEnrichmentJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/vector-enrichment-jobs/{Arn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsGetVectorEnrichmentJobInput(input, restEncoder); 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_serializeOpHttpBindingsGetVectorEnrichmentJobInput(v *GetVectorEnrichmentJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Arn == nil || len(*v.Arn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Arn must not be empty")}
}
if v.Arn != nil {
if err := encoder.SetURI("Arn").String(*v.Arn); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListEarthObservationJobs struct {
}
func (*awsRestjson1_serializeOpListEarthObservationJobs) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListEarthObservationJobs) 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.(*ListEarthObservationJobsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/list-earth-observation-jobs")
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_serializeOpDocumentListEarthObservationJobsInput(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_serializeOpHttpBindingsListEarthObservationJobsInput(v *ListEarthObservationJobsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentListEarthObservationJobsInput(v *ListEarthObservationJobsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.SortBy != nil {
ok := object.Key("SortBy")
ok.String(*v.SortBy)
}
if len(v.SortOrder) > 0 {
ok := object.Key("SortOrder")
ok.String(string(v.SortOrder))
}
if len(v.StatusEquals) > 0 {
ok := object.Key("StatusEquals")
ok.String(string(v.StatusEquals))
}
return nil
}
type awsRestjson1_serializeOpListRasterDataCollections struct {
}
func (*awsRestjson1_serializeOpListRasterDataCollections) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListRasterDataCollections) 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.(*ListRasterDataCollectionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/raster-data-collections")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListRasterDataCollectionsInput(input, restEncoder); 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_serializeOpHttpBindingsListRasterDataCollectionsInput(v *ListRasterDataCollectionsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != nil {
encoder.SetQuery("MaxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("NextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListTagsForResource struct {
}
func (*awsRestjson1_serializeOpListTagsForResource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListTagsForResource) 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.(*ListTagsForResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "GET"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); 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_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
}
if v.ResourceArn != nil {
if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListVectorEnrichmentJobs struct {
}
func (*awsRestjson1_serializeOpListVectorEnrichmentJobs) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListVectorEnrichmentJobs) 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.(*ListVectorEnrichmentJobsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/list-vector-enrichment-jobs")
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_serializeOpDocumentListVectorEnrichmentJobsInput(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_serializeOpHttpBindingsListVectorEnrichmentJobsInput(v *ListVectorEnrichmentJobsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentListVectorEnrichmentJobsInput(v *ListVectorEnrichmentJobsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.SortBy != nil {
ok := object.Key("SortBy")
ok.String(*v.SortBy)
}
if len(v.SortOrder) > 0 {
ok := object.Key("SortOrder")
ok.String(string(v.SortOrder))
}
if v.StatusEquals != nil {
ok := object.Key("StatusEquals")
ok.String(*v.StatusEquals)
}
return nil
}
type awsRestjson1_serializeOpSearchRasterDataCollection struct {
}
func (*awsRestjson1_serializeOpSearchRasterDataCollection) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpSearchRasterDataCollection) 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.(*SearchRasterDataCollectionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/search-raster-data-collection")
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_serializeOpDocumentSearchRasterDataCollectionInput(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_serializeOpHttpBindingsSearchRasterDataCollectionInput(v *SearchRasterDataCollectionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentSearchRasterDataCollectionInput(v *SearchRasterDataCollectionInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Arn != nil {
ok := object.Key("Arn")
ok.String(*v.Arn)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.RasterDataCollectionQuery != nil {
ok := object.Key("RasterDataCollectionQuery")
if err := awsRestjson1_serializeDocumentRasterDataCollectionQueryWithBandFilterInput(v.RasterDataCollectionQuery, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpStartEarthObservationJob struct {
}
func (*awsRestjson1_serializeOpStartEarthObservationJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartEarthObservationJob) 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.(*StartEarthObservationJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/earth-observation-jobs")
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_serializeOpDocumentStartEarthObservationJobInput(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_serializeOpHttpBindingsStartEarthObservationJobInput(v *StartEarthObservationJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentStartEarthObservationJobInput(v *StartEarthObservationJobInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientToken != nil {
ok := object.Key("ClientToken")
ok.String(*v.ClientToken)
}
if v.ExecutionRoleArn != nil {
ok := object.Key("ExecutionRoleArn")
ok.String(*v.ExecutionRoleArn)
}
if v.InputConfig != nil {
ok := object.Key("InputConfig")
if err := awsRestjson1_serializeDocumentInputConfigInput(v.InputConfig, ok); err != nil {
return err
}
}
if v.JobConfig != nil {
ok := object.Key("JobConfig")
if err := awsRestjson1_serializeDocumentJobConfigInput(v.JobConfig, ok); err != nil {
return err
}
}
if v.KmsKeyId != nil {
ok := object.Key("KmsKeyId")
ok.String(*v.KmsKeyId)
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpStartVectorEnrichmentJob struct {
}
func (*awsRestjson1_serializeOpStartVectorEnrichmentJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartVectorEnrichmentJob) 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.(*StartVectorEnrichmentJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/vector-enrichment-jobs")
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_serializeOpDocumentStartVectorEnrichmentJobInput(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_serializeOpHttpBindingsStartVectorEnrichmentJobInput(v *StartVectorEnrichmentJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentStartVectorEnrichmentJobInput(v *StartVectorEnrichmentJobInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientToken != nil {
ok := object.Key("ClientToken")
ok.String(*v.ClientToken)
}
if v.ExecutionRoleArn != nil {
ok := object.Key("ExecutionRoleArn")
ok.String(*v.ExecutionRoleArn)
}
if v.InputConfig != nil {
ok := object.Key("InputConfig")
if err := awsRestjson1_serializeDocumentVectorEnrichmentJobInputConfig(v.InputConfig, ok); err != nil {
return err
}
}
if v.JobConfig != nil {
ok := object.Key("JobConfig")
if err := awsRestjson1_serializeDocumentVectorEnrichmentJobConfig(v.JobConfig, ok); err != nil {
return err
}
}
if v.KmsKeyId != nil {
ok := object.Key("KmsKeyId")
ok.String(*v.KmsKeyId)
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpStopEarthObservationJob struct {
}
func (*awsRestjson1_serializeOpStopEarthObservationJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStopEarthObservationJob) 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.(*StopEarthObservationJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/earth-observation-jobs/stop")
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_serializeOpDocumentStopEarthObservationJobInput(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_serializeOpHttpBindingsStopEarthObservationJobInput(v *StopEarthObservationJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentStopEarthObservationJobInput(v *StopEarthObservationJobInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Arn != nil {
ok := object.Key("Arn")
ok.String(*v.Arn)
}
return nil
}
type awsRestjson1_serializeOpStopVectorEnrichmentJob struct {
}
func (*awsRestjson1_serializeOpStopVectorEnrichmentJob) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStopVectorEnrichmentJob) 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.(*StopVectorEnrichmentJobInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/vector-enrichment-jobs/stop")
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_serializeOpDocumentStopVectorEnrichmentJobInput(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_serializeOpHttpBindingsStopVectorEnrichmentJobInput(v *StopVectorEnrichmentJobInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentStopVectorEnrichmentJobInput(v *StopVectorEnrichmentJobInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Arn != nil {
ok := object.Key("Arn")
ok.String(*v.Arn)
}
return nil
}
type awsRestjson1_serializeOpTagResource struct {
}
func (*awsRestjson1_serializeOpTagResource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpTagResource) 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.(*TagResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PUT"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentTagResourceInput(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_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
}
if v.ResourceArn != nil {
if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUntagResource struct {
}
func (*awsRestjson1_serializeOpUntagResource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUntagResource) 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.(*UntagResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); 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_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
}
if v.ResourceArn != nil {
if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
return err
}
}
if v.TagKeys != nil {
for i := range v.TagKeys {
encoder.AddQuery("tagKeys").String(v.TagKeys[i])
}
}
return nil
}
func awsRestjson1_serializeDocumentAreaOfInterest(v types.AreaOfInterest, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.AreaOfInterestMemberAreaOfInterestGeometry:
av := object.Key("AreaOfInterestGeometry")
if err := awsRestjson1_serializeDocumentAreaOfInterestGeometry(uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentAreaOfInterestGeometry(v types.AreaOfInterestGeometry, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.AreaOfInterestGeometryMemberMultiPolygonGeometry:
av := object.Key("MultiPolygonGeometry")
if err := awsRestjson1_serializeDocumentMultiPolygonGeometryInput(&uv.Value, av); err != nil {
return err
}
case *types.AreaOfInterestGeometryMemberPolygonGeometry:
av := object.Key("PolygonGeometry")
if err := awsRestjson1_serializeDocumentPolygonGeometryInput(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentBandMathConfigInput(v *types.BandMathConfigInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CustomIndices != nil {
ok := object.Key("CustomIndices")
if err := awsRestjson1_serializeDocumentCustomIndicesInput(v.CustomIndices, ok); err != nil {
return err
}
}
if v.PredefinedIndices != nil {
ok := object.Key("PredefinedIndices")
if err := awsRestjson1_serializeDocumentStringListInput(v.PredefinedIndices, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentCloudMaskingConfigInput(v *types.CloudMaskingConfigInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsRestjson1_serializeDocumentCloudRemovalConfigInput(v *types.CloudRemovalConfigInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.AlgorithmName) > 0 {
ok := object.Key("AlgorithmName")
ok.String(string(v.AlgorithmName))
}
if v.InterpolationValue != nil {
ok := object.Key("InterpolationValue")
ok.String(*v.InterpolationValue)
}
if v.TargetBands != nil {
ok := object.Key("TargetBands")
if err := awsRestjson1_serializeDocumentStringListInput(v.TargetBands, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentCustomIndicesInput(v *types.CustomIndicesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Operations != nil {
ok := object.Key("Operations")
if err := awsRestjson1_serializeDocumentOperationsListInput(v.Operations, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentEoCloudCoverInput(v *types.EoCloudCoverInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LowerBound != nil {
ok := object.Key("LowerBound")
switch {
case math.IsNaN(float64(*v.LowerBound)):
ok.String("NaN")
case math.IsInf(float64(*v.LowerBound), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.LowerBound), -1):
ok.String("-Infinity")
default:
ok.Float(*v.LowerBound)
}
}
if v.UpperBound != nil {
ok := object.Key("UpperBound")
switch {
case math.IsNaN(float64(*v.UpperBound)):
ok.String("NaN")
case math.IsInf(float64(*v.UpperBound), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.UpperBound), -1):
ok.String("-Infinity")
default:
ok.Float(*v.UpperBound)
}
}
return nil
}
func awsRestjson1_serializeDocumentExportS3DataInput(v *types.ExportS3DataInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.KmsKeyId != nil {
ok := object.Key("KmsKeyId")
ok.String(*v.KmsKeyId)
}
if v.S3Uri != nil {
ok := object.Key("S3Uri")
ok.String(*v.S3Uri)
}
return nil
}
func awsRestjson1_serializeDocumentExportVectorEnrichmentJobOutputConfig(v *types.ExportVectorEnrichmentJobOutputConfig, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.S3Data != nil {
ok := object.Key("S3Data")
if err := awsRestjson1_serializeDocumentVectorEnrichmentJobS3Data(v.S3Data, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentGeoMosaicConfigInput(v *types.GeoMosaicConfigInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.AlgorithmName) > 0 {
ok := object.Key("AlgorithmName")
ok.String(string(v.AlgorithmName))
}
if v.TargetBands != nil {
ok := object.Key("TargetBands")
if err := awsRestjson1_serializeDocumentStringListInput(v.TargetBands, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentInputConfigInput(v *types.InputConfigInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.PreviousEarthObservationJobArn != nil {
ok := object.Key("PreviousEarthObservationJobArn")
ok.String(*v.PreviousEarthObservationJobArn)
}
if v.RasterDataCollectionQuery != nil {
ok := object.Key("RasterDataCollectionQuery")
if err := awsRestjson1_serializeDocumentRasterDataCollectionQueryInput(v.RasterDataCollectionQuery, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentJobConfigInput(v types.JobConfigInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.JobConfigInputMemberBandMathConfig:
av := object.Key("BandMathConfig")
if err := awsRestjson1_serializeDocumentBandMathConfigInput(&uv.Value, av); err != nil {
return err
}
case *types.JobConfigInputMemberCloudMaskingConfig:
av := object.Key("CloudMaskingConfig")
if err := awsRestjson1_serializeDocumentCloudMaskingConfigInput(&uv.Value, av); err != nil {
return err
}
case *types.JobConfigInputMemberCloudRemovalConfig:
av := object.Key("CloudRemovalConfig")
if err := awsRestjson1_serializeDocumentCloudRemovalConfigInput(&uv.Value, av); err != nil {
return err
}
case *types.JobConfigInputMemberGeoMosaicConfig:
av := object.Key("GeoMosaicConfig")
if err := awsRestjson1_serializeDocumentGeoMosaicConfigInput(&uv.Value, av); err != nil {
return err
}
case *types.JobConfigInputMemberLandCoverSegmentationConfig:
av := object.Key("LandCoverSegmentationConfig")
if err := awsRestjson1_serializeDocumentLandCoverSegmentationConfigInput(&uv.Value, av); err != nil {
return err
}
case *types.JobConfigInputMemberResamplingConfig:
av := object.Key("ResamplingConfig")
if err := awsRestjson1_serializeDocumentResamplingConfigInput(&uv.Value, av); err != nil {
return err
}
case *types.JobConfigInputMemberStackConfig:
av := object.Key("StackConfig")
if err := awsRestjson1_serializeDocumentStackConfigInput(&uv.Value, av); err != nil {
return err
}
case *types.JobConfigInputMemberTemporalStatisticsConfig:
av := object.Key("TemporalStatisticsConfig")
if err := awsRestjson1_serializeDocumentTemporalStatisticsConfigInput(&uv.Value, av); err != nil {
return err
}
case *types.JobConfigInputMemberZonalStatisticsConfig:
av := object.Key("ZonalStatisticsConfig")
if err := awsRestjson1_serializeDocumentZonalStatisticsConfigInput(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentLandCoverSegmentationConfigInput(v *types.LandCoverSegmentationConfigInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsRestjson1_serializeDocumentLandsatCloudCoverLandInput(v *types.LandsatCloudCoverLandInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LowerBound != nil {
ok := object.Key("LowerBound")
switch {
case math.IsNaN(float64(*v.LowerBound)):
ok.String("NaN")
case math.IsInf(float64(*v.LowerBound), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.LowerBound), -1):
ok.String("-Infinity")
default:
ok.Float(*v.LowerBound)
}
}
if v.UpperBound != nil {
ok := object.Key("UpperBound")
switch {
case math.IsNaN(float64(*v.UpperBound)):
ok.String("NaN")
case math.IsInf(float64(*v.UpperBound), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.UpperBound), -1):
ok.String("-Infinity")
default:
ok.Float(*v.UpperBound)
}
}
return nil
}
func awsRestjson1_serializeDocumentLinearRing(v [][]float64, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if vv := v[i]; vv == nil {
continue
}
if err := awsRestjson1_serializeDocumentPosition(v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentLinearRings(v [][][]float64, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if vv := v[i]; vv == nil {
continue
}
if err := awsRestjson1_serializeDocumentLinearRing(v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentLinearRingsList(v [][][][]float64, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if vv := v[i]; vv == nil {
continue
}
if err := awsRestjson1_serializeDocumentLinearRings(v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentMapMatchingConfig(v *types.MapMatchingConfig, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.IdAttributeName != nil {
ok := object.Key("IdAttributeName")
ok.String(*v.IdAttributeName)
}
if v.TimestampAttributeName != nil {
ok := object.Key("TimestampAttributeName")
ok.String(*v.TimestampAttributeName)
}
if v.XAttributeName != nil {
ok := object.Key("XAttributeName")
ok.String(*v.XAttributeName)
}
if v.YAttributeName != nil {
ok := object.Key("YAttributeName")
ok.String(*v.YAttributeName)
}
return nil
}
func awsRestjson1_serializeDocumentMultiPolygonGeometryInput(v *types.MultiPolygonGeometryInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Coordinates != nil {
ok := object.Key("Coordinates")
if err := awsRestjson1_serializeDocumentLinearRingsList(v.Coordinates, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentOperation(v *types.Operation, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Equation != nil {
ok := object.Key("Equation")
ok.String(*v.Equation)
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if len(v.OutputType) > 0 {
ok := object.Key("OutputType")
ok.String(string(v.OutputType))
}
return nil
}
func awsRestjson1_serializeDocumentOperationsListInput(v []types.Operation, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentOperation(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentOutputConfigInput(v *types.OutputConfigInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.S3Data != nil {
ok := object.Key("S3Data")
if err := awsRestjson1_serializeDocumentExportS3DataInput(v.S3Data, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentOutputResolutionResamplingInput(v *types.OutputResolutionResamplingInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.UserDefined != nil {
ok := object.Key("UserDefined")
if err := awsRestjson1_serializeDocumentUserDefined(v.UserDefined, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentOutputResolutionStackInput(v *types.OutputResolutionStackInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Predefined) > 0 {
ok := object.Key("Predefined")
ok.String(string(v.Predefined))
}
if v.UserDefined != nil {
ok := object.Key("UserDefined")
if err := awsRestjson1_serializeDocumentUserDefined(v.UserDefined, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentPlatformInput(v *types.PlatformInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.ComparisonOperator) > 0 {
ok := object.Key("ComparisonOperator")
ok.String(string(v.ComparisonOperator))
}
if v.Value != nil {
ok := object.Key("Value")
ok.String(*v.Value)
}
return nil
}
func awsRestjson1_serializeDocumentPolygonGeometryInput(v *types.PolygonGeometryInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Coordinates != nil {
ok := object.Key("Coordinates")
if err := awsRestjson1_serializeDocumentLinearRings(v.Coordinates, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentPosition(v []float64, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
switch {
case math.IsNaN(v[i]):
av.String("NaN")
case math.IsInf(v[i], 1):
av.String("Infinity")
case math.IsInf(v[i], -1):
av.String("-Infinity")
default:
av.Double(v[i])
}
}
return nil
}
func awsRestjson1_serializeDocumentProperty(v types.Property, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.PropertyMemberEoCloudCover:
av := object.Key("EoCloudCover")
if err := awsRestjson1_serializeDocumentEoCloudCoverInput(&uv.Value, av); err != nil {
return err
}
case *types.PropertyMemberLandsatCloudCoverLand:
av := object.Key("LandsatCloudCoverLand")
if err := awsRestjson1_serializeDocumentLandsatCloudCoverLandInput(&uv.Value, av); err != nil {
return err
}
case *types.PropertyMemberPlatform:
av := object.Key("Platform")
if err := awsRestjson1_serializeDocumentPlatformInput(&uv.Value, av); err != nil {
return err
}
case *types.PropertyMemberViewOffNadir:
av := object.Key("ViewOffNadir")
if err := awsRestjson1_serializeDocumentViewOffNadirInput(&uv.Value, av); err != nil {
return err
}
case *types.PropertyMemberViewSunAzimuth:
av := object.Key("ViewSunAzimuth")
if err := awsRestjson1_serializeDocumentViewSunAzimuthInput(&uv.Value, av); err != nil {
return err
}
case *types.PropertyMemberViewSunElevation:
av := object.Key("ViewSunElevation")
if err := awsRestjson1_serializeDocumentViewSunElevationInput(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentPropertyFilter(v *types.PropertyFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Property != nil {
ok := object.Key("Property")
if err := awsRestjson1_serializeDocumentProperty(v.Property, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentPropertyFilters(v *types.PropertyFilters, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.LogicalOperator) > 0 {
ok := object.Key("LogicalOperator")
ok.String(string(v.LogicalOperator))
}
if v.Properties != nil {
ok := object.Key("Properties")
if err := awsRestjson1_serializeDocumentPropertyFiltersList(v.Properties, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentPropertyFiltersList(v []types.PropertyFilter, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentPropertyFilter(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentRasterDataCollectionQueryInput(v *types.RasterDataCollectionQueryInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AreaOfInterest != nil {
ok := object.Key("AreaOfInterest")
if err := awsRestjson1_serializeDocumentAreaOfInterest(v.AreaOfInterest, ok); err != nil {
return err
}
}
if v.PropertyFilters != nil {
ok := object.Key("PropertyFilters")
if err := awsRestjson1_serializeDocumentPropertyFilters(v.PropertyFilters, ok); err != nil {
return err
}
}
if v.RasterDataCollectionArn != nil {
ok := object.Key("RasterDataCollectionArn")
ok.String(*v.RasterDataCollectionArn)
}
if v.TimeRangeFilter != nil {
ok := object.Key("TimeRangeFilter")
if err := awsRestjson1_serializeDocumentTimeRangeFilterInput(v.TimeRangeFilter, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentRasterDataCollectionQueryWithBandFilterInput(v *types.RasterDataCollectionQueryWithBandFilterInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AreaOfInterest != nil {
ok := object.Key("AreaOfInterest")
if err := awsRestjson1_serializeDocumentAreaOfInterest(v.AreaOfInterest, ok); err != nil {
return err
}
}
if v.BandFilter != nil {
ok := object.Key("BandFilter")
if err := awsRestjson1_serializeDocumentStringListInput(v.BandFilter, ok); err != nil {
return err
}
}
if v.PropertyFilters != nil {
ok := object.Key("PropertyFilters")
if err := awsRestjson1_serializeDocumentPropertyFilters(v.PropertyFilters, ok); err != nil {
return err
}
}
if v.TimeRangeFilter != nil {
ok := object.Key("TimeRangeFilter")
if err := awsRestjson1_serializeDocumentTimeRangeFilterInput(v.TimeRangeFilter, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentResamplingConfigInput(v *types.ResamplingConfigInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.AlgorithmName) > 0 {
ok := object.Key("AlgorithmName")
ok.String(string(v.AlgorithmName))
}
if v.OutputResolution != nil {
ok := object.Key("OutputResolution")
if err := awsRestjson1_serializeDocumentOutputResolutionResamplingInput(v.OutputResolution, ok); err != nil {
return err
}
}
if v.TargetBands != nil {
ok := object.Key("TargetBands")
if err := awsRestjson1_serializeDocumentStringListInput(v.TargetBands, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentReverseGeocodingConfig(v *types.ReverseGeocodingConfig, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.XAttributeName != nil {
ok := object.Key("XAttributeName")
ok.String(*v.XAttributeName)
}
if v.YAttributeName != nil {
ok := object.Key("YAttributeName")
ok.String(*v.YAttributeName)
}
return nil
}
func awsRestjson1_serializeDocumentStackConfigInput(v *types.StackConfigInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.OutputResolution != nil {
ok := object.Key("OutputResolution")
if err := awsRestjson1_serializeDocumentOutputResolutionStackInput(v.OutputResolution, ok); err != nil {
return err
}
}
if v.TargetBands != nil {
ok := object.Key("TargetBands")
if err := awsRestjson1_serializeDocumentStringListInput(v.TargetBands, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentStringListInput(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_serializeDocumentTags(v map[string]string, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
om.String(v[key])
}
return nil
}
func awsRestjson1_serializeDocumentTemporalStatisticsConfigInput(v *types.TemporalStatisticsConfigInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.GroupBy) > 0 {
ok := object.Key("GroupBy")
ok.String(string(v.GroupBy))
}
if v.Statistics != nil {
ok := object.Key("Statistics")
if err := awsRestjson1_serializeDocumentTemporalStatisticsListInput(v.Statistics, ok); err != nil {
return err
}
}
if v.TargetBands != nil {
ok := object.Key("TargetBands")
if err := awsRestjson1_serializeDocumentStringListInput(v.TargetBands, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentTemporalStatisticsListInput(v []types.TemporalStatistics, 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 awsRestjson1_serializeDocumentTimeRangeFilterInput(v *types.TimeRangeFilterInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.EndTime != nil {
ok := object.Key("EndTime")
ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
}
if v.StartTime != nil {
ok := object.Key("StartTime")
ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
}
return nil
}
func awsRestjson1_serializeDocumentUserDefined(v *types.UserDefined, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Unit) > 0 {
ok := object.Key("Unit")
ok.String(string(v.Unit))
}
if v.Value != nil {
ok := object.Key("Value")
switch {
case math.IsNaN(float64(*v.Value)):
ok.String("NaN")
case math.IsInf(float64(*v.Value), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.Value), -1):
ok.String("-Infinity")
default:
ok.Float(*v.Value)
}
}
return nil
}
func awsRestjson1_serializeDocumentVectorEnrichmentJobConfig(v types.VectorEnrichmentJobConfig, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.VectorEnrichmentJobConfigMemberMapMatchingConfig:
av := object.Key("MapMatchingConfig")
if err := awsRestjson1_serializeDocumentMapMatchingConfig(&uv.Value, av); err != nil {
return err
}
case *types.VectorEnrichmentJobConfigMemberReverseGeocodingConfig:
av := object.Key("ReverseGeocodingConfig")
if err := awsRestjson1_serializeDocumentReverseGeocodingConfig(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentVectorEnrichmentJobDataSourceConfigInput(v types.VectorEnrichmentJobDataSourceConfigInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.VectorEnrichmentJobDataSourceConfigInputMemberS3Data:
av := object.Key("S3Data")
if err := awsRestjson1_serializeDocumentVectorEnrichmentJobS3Data(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentVectorEnrichmentJobInputConfig(v *types.VectorEnrichmentJobInputConfig, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DataSourceConfig != nil {
ok := object.Key("DataSourceConfig")
if err := awsRestjson1_serializeDocumentVectorEnrichmentJobDataSourceConfigInput(v.DataSourceConfig, ok); err != nil {
return err
}
}
if len(v.DocumentType) > 0 {
ok := object.Key("DocumentType")
ok.String(string(v.DocumentType))
}
return nil
}
func awsRestjson1_serializeDocumentVectorEnrichmentJobS3Data(v *types.VectorEnrichmentJobS3Data, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.KmsKeyId != nil {
ok := object.Key("KmsKeyId")
ok.String(*v.KmsKeyId)
}
if v.S3Uri != nil {
ok := object.Key("S3Uri")
ok.String(*v.S3Uri)
}
return nil
}
func awsRestjson1_serializeDocumentViewOffNadirInput(v *types.ViewOffNadirInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LowerBound != nil {
ok := object.Key("LowerBound")
switch {
case math.IsNaN(float64(*v.LowerBound)):
ok.String("NaN")
case math.IsInf(float64(*v.LowerBound), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.LowerBound), -1):
ok.String("-Infinity")
default:
ok.Float(*v.LowerBound)
}
}
if v.UpperBound != nil {
ok := object.Key("UpperBound")
switch {
case math.IsNaN(float64(*v.UpperBound)):
ok.String("NaN")
case math.IsInf(float64(*v.UpperBound), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.UpperBound), -1):
ok.String("-Infinity")
default:
ok.Float(*v.UpperBound)
}
}
return nil
}
func awsRestjson1_serializeDocumentViewSunAzimuthInput(v *types.ViewSunAzimuthInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LowerBound != nil {
ok := object.Key("LowerBound")
switch {
case math.IsNaN(float64(*v.LowerBound)):
ok.String("NaN")
case math.IsInf(float64(*v.LowerBound), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.LowerBound), -1):
ok.String("-Infinity")
default:
ok.Float(*v.LowerBound)
}
}
if v.UpperBound != nil {
ok := object.Key("UpperBound")
switch {
case math.IsNaN(float64(*v.UpperBound)):
ok.String("NaN")
case math.IsInf(float64(*v.UpperBound), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.UpperBound), -1):
ok.String("-Infinity")
default:
ok.Float(*v.UpperBound)
}
}
return nil
}
func awsRestjson1_serializeDocumentViewSunElevationInput(v *types.ViewSunElevationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LowerBound != nil {
ok := object.Key("LowerBound")
switch {
case math.IsNaN(float64(*v.LowerBound)):
ok.String("NaN")
case math.IsInf(float64(*v.LowerBound), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.LowerBound), -1):
ok.String("-Infinity")
default:
ok.Float(*v.LowerBound)
}
}
if v.UpperBound != nil {
ok := object.Key("UpperBound")
switch {
case math.IsNaN(float64(*v.UpperBound)):
ok.String("NaN")
case math.IsInf(float64(*v.UpperBound), 1):
ok.String("Infinity")
case math.IsInf(float64(*v.UpperBound), -1):
ok.String("-Infinity")
default:
ok.Float(*v.UpperBound)
}
}
return nil
}
func awsRestjson1_serializeDocumentZonalStatisticsConfigInput(v *types.ZonalStatisticsConfigInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Statistics != nil {
ok := object.Key("Statistics")
if err := awsRestjson1_serializeDocumentZonalStatisticsListInput(v.Statistics, ok); err != nil {
return err
}
}
if v.TargetBands != nil {
ok := object.Key("TargetBands")
if err := awsRestjson1_serializeDocumentStringListInput(v.TargetBands, ok); err != nil {
return err
}
}
if v.ZoneS3Path != nil {
ok := object.Key("ZoneS3Path")
ok.String(*v.ZoneS3Path)
}
if v.ZoneS3PathKmsKeyId != nil {
ok := object.Key("ZoneS3PathKmsKeyId")
ok.String(*v.ZoneS3PathKmsKeyId)
}
return nil
}
func awsRestjson1_serializeDocumentZonalStatisticsListInput(v []types.ZonalStatistics, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(string(v[i]))
}
return nil
}
| 2,602 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakergeospatial
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/sagemakergeospatial/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpDeleteEarthObservationJob struct {
}
func (*validateOpDeleteEarthObservationJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteEarthObservationJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteEarthObservationJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteEarthObservationJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteVectorEnrichmentJob struct {
}
func (*validateOpDeleteVectorEnrichmentJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteVectorEnrichmentJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteVectorEnrichmentJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteVectorEnrichmentJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpExportEarthObservationJob struct {
}
func (*validateOpExportEarthObservationJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpExportEarthObservationJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ExportEarthObservationJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpExportEarthObservationJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpExportVectorEnrichmentJob struct {
}
func (*validateOpExportVectorEnrichmentJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpExportVectorEnrichmentJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ExportVectorEnrichmentJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpExportVectorEnrichmentJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetEarthObservationJob struct {
}
func (*validateOpGetEarthObservationJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetEarthObservationJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetEarthObservationJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetEarthObservationJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetRasterDataCollection struct {
}
func (*validateOpGetRasterDataCollection) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetRasterDataCollection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetRasterDataCollectionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetRasterDataCollectionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetTile struct {
}
func (*validateOpGetTile) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetTile) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetTileInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetTileInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetVectorEnrichmentJob struct {
}
func (*validateOpGetVectorEnrichmentJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetVectorEnrichmentJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetVectorEnrichmentJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetVectorEnrichmentJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListTagsForResource struct {
}
func (*validateOpListTagsForResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListTagsForResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListTagsForResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpSearchRasterDataCollection struct {
}
func (*validateOpSearchRasterDataCollection) ID() string {
return "OperationInputValidation"
}
func (m *validateOpSearchRasterDataCollection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*SearchRasterDataCollectionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpSearchRasterDataCollectionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartEarthObservationJob struct {
}
func (*validateOpStartEarthObservationJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartEarthObservationJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartEarthObservationJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartEarthObservationJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartVectorEnrichmentJob struct {
}
func (*validateOpStartVectorEnrichmentJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartVectorEnrichmentJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartVectorEnrichmentJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartVectorEnrichmentJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStopEarthObservationJob struct {
}
func (*validateOpStopEarthObservationJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStopEarthObservationJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StopEarthObservationJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStopEarthObservationJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStopVectorEnrichmentJob struct {
}
func (*validateOpStopVectorEnrichmentJob) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStopVectorEnrichmentJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StopVectorEnrichmentJobInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStopVectorEnrichmentJobInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpTagResource struct {
}
func (*validateOpTagResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*TagResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpTagResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUntagResource struct {
}
func (*validateOpUntagResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UntagResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUntagResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpDeleteEarthObservationJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteEarthObservationJob{}, middleware.After)
}
func addOpDeleteVectorEnrichmentJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteVectorEnrichmentJob{}, middleware.After)
}
func addOpExportEarthObservationJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpExportEarthObservationJob{}, middleware.After)
}
func addOpExportVectorEnrichmentJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpExportVectorEnrichmentJob{}, middleware.After)
}
func addOpGetEarthObservationJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetEarthObservationJob{}, middleware.After)
}
func addOpGetRasterDataCollectionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetRasterDataCollection{}, middleware.After)
}
func addOpGetTileValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetTile{}, middleware.After)
}
func addOpGetVectorEnrichmentJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetVectorEnrichmentJob{}, middleware.After)
}
func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
}
func addOpSearchRasterDataCollectionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpSearchRasterDataCollection{}, middleware.After)
}
func addOpStartEarthObservationJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartEarthObservationJob{}, middleware.After)
}
func addOpStartVectorEnrichmentJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartVectorEnrichmentJob{}, middleware.After)
}
func addOpStopEarthObservationJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStopEarthObservationJob{}, middleware.After)
}
func addOpStopVectorEnrichmentJobValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStopVectorEnrichmentJob{}, middleware.After)
}
func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
}
func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
}
func validateAreaOfInterest(v types.AreaOfInterest) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AreaOfInterest"}
switch uv := v.(type) {
case *types.AreaOfInterestMemberAreaOfInterestGeometry:
if err := validateAreaOfInterestGeometry(uv.Value); err != nil {
invalidParams.AddNested("[AreaOfInterestGeometry]", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAreaOfInterestGeometry(v types.AreaOfInterestGeometry) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AreaOfInterestGeometry"}
switch uv := v.(type) {
case *types.AreaOfInterestGeometryMemberMultiPolygonGeometry:
if err := validateMultiPolygonGeometryInput(&uv.Value); err != nil {
invalidParams.AddNested("[MultiPolygonGeometry]", err.(smithy.InvalidParamsError))
}
case *types.AreaOfInterestGeometryMemberPolygonGeometry:
if err := validatePolygonGeometryInput(&uv.Value); err != nil {
invalidParams.AddNested("[PolygonGeometry]", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateBandMathConfigInput(v *types.BandMathConfigInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BandMathConfigInput"}
if v.CustomIndices != nil {
if err := validateCustomIndicesInput(v.CustomIndices); err != nil {
invalidParams.AddNested("CustomIndices", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCustomIndicesInput(v *types.CustomIndicesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CustomIndicesInput"}
if v.Operations != nil {
if err := validateOperationsListInput(v.Operations); err != nil {
invalidParams.AddNested("Operations", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateEoCloudCoverInput(v *types.EoCloudCoverInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "EoCloudCoverInput"}
if v.LowerBound == nil {
invalidParams.Add(smithy.NewErrParamRequired("LowerBound"))
}
if v.UpperBound == nil {
invalidParams.Add(smithy.NewErrParamRequired("UpperBound"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateExportS3DataInput(v *types.ExportS3DataInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ExportS3DataInput"}
if v.S3Uri == nil {
invalidParams.Add(smithy.NewErrParamRequired("S3Uri"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateExportVectorEnrichmentJobOutputConfig(v *types.ExportVectorEnrichmentJobOutputConfig) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ExportVectorEnrichmentJobOutputConfig"}
if v.S3Data == nil {
invalidParams.Add(smithy.NewErrParamRequired("S3Data"))
} else if v.S3Data != nil {
if err := validateVectorEnrichmentJobS3Data(v.S3Data); err != nil {
invalidParams.AddNested("S3Data", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateInputConfigInput(v *types.InputConfigInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "InputConfigInput"}
if v.RasterDataCollectionQuery != nil {
if err := validateRasterDataCollectionQueryInput(v.RasterDataCollectionQuery); err != nil {
invalidParams.AddNested("RasterDataCollectionQuery", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateJobConfigInput(v types.JobConfigInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "JobConfigInput"}
switch uv := v.(type) {
case *types.JobConfigInputMemberBandMathConfig:
if err := validateBandMathConfigInput(&uv.Value); err != nil {
invalidParams.AddNested("[BandMathConfig]", err.(smithy.InvalidParamsError))
}
case *types.JobConfigInputMemberResamplingConfig:
if err := validateResamplingConfigInput(&uv.Value); err != nil {
invalidParams.AddNested("[ResamplingConfig]", err.(smithy.InvalidParamsError))
}
case *types.JobConfigInputMemberStackConfig:
if err := validateStackConfigInput(&uv.Value); err != nil {
invalidParams.AddNested("[StackConfig]", err.(smithy.InvalidParamsError))
}
case *types.JobConfigInputMemberTemporalStatisticsConfig:
if err := validateTemporalStatisticsConfigInput(&uv.Value); err != nil {
invalidParams.AddNested("[TemporalStatisticsConfig]", err.(smithy.InvalidParamsError))
}
case *types.JobConfigInputMemberZonalStatisticsConfig:
if err := validateZonalStatisticsConfigInput(&uv.Value); err != nil {
invalidParams.AddNested("[ZonalStatisticsConfig]", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateLandsatCloudCoverLandInput(v *types.LandsatCloudCoverLandInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "LandsatCloudCoverLandInput"}
if v.LowerBound == nil {
invalidParams.Add(smithy.NewErrParamRequired("LowerBound"))
}
if v.UpperBound == nil {
invalidParams.Add(smithy.NewErrParamRequired("UpperBound"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateMapMatchingConfig(v *types.MapMatchingConfig) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "MapMatchingConfig"}
if v.IdAttributeName == nil {
invalidParams.Add(smithy.NewErrParamRequired("IdAttributeName"))
}
if v.YAttributeName == nil {
invalidParams.Add(smithy.NewErrParamRequired("YAttributeName"))
}
if v.XAttributeName == nil {
invalidParams.Add(smithy.NewErrParamRequired("XAttributeName"))
}
if v.TimestampAttributeName == nil {
invalidParams.Add(smithy.NewErrParamRequired("TimestampAttributeName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateMultiPolygonGeometryInput(v *types.MultiPolygonGeometryInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "MultiPolygonGeometryInput"}
if v.Coordinates == nil {
invalidParams.Add(smithy.NewErrParamRequired("Coordinates"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOperation(v *types.Operation) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Operation"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.Equation == nil {
invalidParams.Add(smithy.NewErrParamRequired("Equation"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOperationsListInput(v []types.Operation) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "OperationsListInput"}
for i := range v {
if err := validateOperation(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOutputConfigInput(v *types.OutputConfigInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "OutputConfigInput"}
if v.S3Data == nil {
invalidParams.Add(smithy.NewErrParamRequired("S3Data"))
} else if v.S3Data != nil {
if err := validateExportS3DataInput(v.S3Data); err != nil {
invalidParams.AddNested("S3Data", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOutputResolutionResamplingInput(v *types.OutputResolutionResamplingInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "OutputResolutionResamplingInput"}
if v.UserDefined == nil {
invalidParams.Add(smithy.NewErrParamRequired("UserDefined"))
} else if v.UserDefined != nil {
if err := validateUserDefined(v.UserDefined); err != nil {
invalidParams.AddNested("UserDefined", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOutputResolutionStackInput(v *types.OutputResolutionStackInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "OutputResolutionStackInput"}
if v.UserDefined != nil {
if err := validateUserDefined(v.UserDefined); err != nil {
invalidParams.AddNested("UserDefined", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validatePlatformInput(v *types.PlatformInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PlatformInput"}
if v.Value == nil {
invalidParams.Add(smithy.NewErrParamRequired("Value"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validatePolygonGeometryInput(v *types.PolygonGeometryInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PolygonGeometryInput"}
if v.Coordinates == nil {
invalidParams.Add(smithy.NewErrParamRequired("Coordinates"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateProperty(v types.Property) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Property"}
switch uv := v.(type) {
case *types.PropertyMemberEoCloudCover:
if err := validateEoCloudCoverInput(&uv.Value); err != nil {
invalidParams.AddNested("[EoCloudCover]", err.(smithy.InvalidParamsError))
}
case *types.PropertyMemberLandsatCloudCoverLand:
if err := validateLandsatCloudCoverLandInput(&uv.Value); err != nil {
invalidParams.AddNested("[LandsatCloudCoverLand]", err.(smithy.InvalidParamsError))
}
case *types.PropertyMemberPlatform:
if err := validatePlatformInput(&uv.Value); err != nil {
invalidParams.AddNested("[Platform]", err.(smithy.InvalidParamsError))
}
case *types.PropertyMemberViewOffNadir:
if err := validateViewOffNadirInput(&uv.Value); err != nil {
invalidParams.AddNested("[ViewOffNadir]", err.(smithy.InvalidParamsError))
}
case *types.PropertyMemberViewSunAzimuth:
if err := validateViewSunAzimuthInput(&uv.Value); err != nil {
invalidParams.AddNested("[ViewSunAzimuth]", err.(smithy.InvalidParamsError))
}
case *types.PropertyMemberViewSunElevation:
if err := validateViewSunElevationInput(&uv.Value); err != nil {
invalidParams.AddNested("[ViewSunElevation]", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validatePropertyFilter(v *types.PropertyFilter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PropertyFilter"}
if v.Property == nil {
invalidParams.Add(smithy.NewErrParamRequired("Property"))
} else if v.Property != nil {
if err := validateProperty(v.Property); err != nil {
invalidParams.AddNested("Property", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validatePropertyFilters(v *types.PropertyFilters) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PropertyFilters"}
if v.Properties != nil {
if err := validatePropertyFiltersList(v.Properties); err != nil {
invalidParams.AddNested("Properties", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validatePropertyFiltersList(v []types.PropertyFilter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PropertyFiltersList"}
for i := range v {
if err := validatePropertyFilter(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateRasterDataCollectionQueryInput(v *types.RasterDataCollectionQueryInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RasterDataCollectionQueryInput"}
if v.RasterDataCollectionArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("RasterDataCollectionArn"))
}
if v.TimeRangeFilter == nil {
invalidParams.Add(smithy.NewErrParamRequired("TimeRangeFilter"))
} else if v.TimeRangeFilter != nil {
if err := validateTimeRangeFilterInput(v.TimeRangeFilter); err != nil {
invalidParams.AddNested("TimeRangeFilter", err.(smithy.InvalidParamsError))
}
}
if v.AreaOfInterest != nil {
if err := validateAreaOfInterest(v.AreaOfInterest); err != nil {
invalidParams.AddNested("AreaOfInterest", err.(smithy.InvalidParamsError))
}
}
if v.PropertyFilters != nil {
if err := validatePropertyFilters(v.PropertyFilters); err != nil {
invalidParams.AddNested("PropertyFilters", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateRasterDataCollectionQueryWithBandFilterInput(v *types.RasterDataCollectionQueryWithBandFilterInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RasterDataCollectionQueryWithBandFilterInput"}
if v.TimeRangeFilter == nil {
invalidParams.Add(smithy.NewErrParamRequired("TimeRangeFilter"))
} else if v.TimeRangeFilter != nil {
if err := validateTimeRangeFilterInput(v.TimeRangeFilter); err != nil {
invalidParams.AddNested("TimeRangeFilter", err.(smithy.InvalidParamsError))
}
}
if v.AreaOfInterest != nil {
if err := validateAreaOfInterest(v.AreaOfInterest); err != nil {
invalidParams.AddNested("AreaOfInterest", err.(smithy.InvalidParamsError))
}
}
if v.PropertyFilters != nil {
if err := validatePropertyFilters(v.PropertyFilters); err != nil {
invalidParams.AddNested("PropertyFilters", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateResamplingConfigInput(v *types.ResamplingConfigInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ResamplingConfigInput"}
if v.OutputResolution == nil {
invalidParams.Add(smithy.NewErrParamRequired("OutputResolution"))
} else if v.OutputResolution != nil {
if err := validateOutputResolutionResamplingInput(v.OutputResolution); err != nil {
invalidParams.AddNested("OutputResolution", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateReverseGeocodingConfig(v *types.ReverseGeocodingConfig) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ReverseGeocodingConfig"}
if v.YAttributeName == nil {
invalidParams.Add(smithy.NewErrParamRequired("YAttributeName"))
}
if v.XAttributeName == nil {
invalidParams.Add(smithy.NewErrParamRequired("XAttributeName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateStackConfigInput(v *types.StackConfigInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StackConfigInput"}
if v.OutputResolution != nil {
if err := validateOutputResolutionStackInput(v.OutputResolution); err != nil {
invalidParams.AddNested("OutputResolution", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTemporalStatisticsConfigInput(v *types.TemporalStatisticsConfigInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TemporalStatisticsConfigInput"}
if v.Statistics == nil {
invalidParams.Add(smithy.NewErrParamRequired("Statistics"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTimeRangeFilterInput(v *types.TimeRangeFilterInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TimeRangeFilterInput"}
if v.StartTime == nil {
invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
}
if v.EndTime == nil {
invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateUserDefined(v *types.UserDefined) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UserDefined"}
if v.Value == nil {
invalidParams.Add(smithy.NewErrParamRequired("Value"))
}
if len(v.Unit) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Unit"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateVectorEnrichmentJobConfig(v types.VectorEnrichmentJobConfig) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "VectorEnrichmentJobConfig"}
switch uv := v.(type) {
case *types.VectorEnrichmentJobConfigMemberMapMatchingConfig:
if err := validateMapMatchingConfig(&uv.Value); err != nil {
invalidParams.AddNested("[MapMatchingConfig]", err.(smithy.InvalidParamsError))
}
case *types.VectorEnrichmentJobConfigMemberReverseGeocodingConfig:
if err := validateReverseGeocodingConfig(&uv.Value); err != nil {
invalidParams.AddNested("[ReverseGeocodingConfig]", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateVectorEnrichmentJobDataSourceConfigInput(v types.VectorEnrichmentJobDataSourceConfigInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "VectorEnrichmentJobDataSourceConfigInput"}
switch uv := v.(type) {
case *types.VectorEnrichmentJobDataSourceConfigInputMemberS3Data:
if err := validateVectorEnrichmentJobS3Data(&uv.Value); err != nil {
invalidParams.AddNested("[S3Data]", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateVectorEnrichmentJobInputConfig(v *types.VectorEnrichmentJobInputConfig) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "VectorEnrichmentJobInputConfig"}
if len(v.DocumentType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("DocumentType"))
}
if v.DataSourceConfig == nil {
invalidParams.Add(smithy.NewErrParamRequired("DataSourceConfig"))
} else if v.DataSourceConfig != nil {
if err := validateVectorEnrichmentJobDataSourceConfigInput(v.DataSourceConfig); err != nil {
invalidParams.AddNested("DataSourceConfig", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateVectorEnrichmentJobS3Data(v *types.VectorEnrichmentJobS3Data) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "VectorEnrichmentJobS3Data"}
if v.S3Uri == nil {
invalidParams.Add(smithy.NewErrParamRequired("S3Uri"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateViewOffNadirInput(v *types.ViewOffNadirInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ViewOffNadirInput"}
if v.LowerBound == nil {
invalidParams.Add(smithy.NewErrParamRequired("LowerBound"))
}
if v.UpperBound == nil {
invalidParams.Add(smithy.NewErrParamRequired("UpperBound"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateViewSunAzimuthInput(v *types.ViewSunAzimuthInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ViewSunAzimuthInput"}
if v.LowerBound == nil {
invalidParams.Add(smithy.NewErrParamRequired("LowerBound"))
}
if v.UpperBound == nil {
invalidParams.Add(smithy.NewErrParamRequired("UpperBound"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateViewSunElevationInput(v *types.ViewSunElevationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ViewSunElevationInput"}
if v.LowerBound == nil {
invalidParams.Add(smithy.NewErrParamRequired("LowerBound"))
}
if v.UpperBound == nil {
invalidParams.Add(smithy.NewErrParamRequired("UpperBound"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateZonalStatisticsConfigInput(v *types.ZonalStatisticsConfigInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ZonalStatisticsConfigInput"}
if v.ZoneS3Path == nil {
invalidParams.Add(smithy.NewErrParamRequired("ZoneS3Path"))
}
if v.Statistics == nil {
invalidParams.Add(smithy.NewErrParamRequired("Statistics"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteEarthObservationJobInput(v *DeleteEarthObservationJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteEarthObservationJobInput"}
if v.Arn == nil {
invalidParams.Add(smithy.NewErrParamRequired("Arn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteVectorEnrichmentJobInput(v *DeleteVectorEnrichmentJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteVectorEnrichmentJobInput"}
if v.Arn == nil {
invalidParams.Add(smithy.NewErrParamRequired("Arn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpExportEarthObservationJobInput(v *ExportEarthObservationJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ExportEarthObservationJobInput"}
if v.Arn == nil {
invalidParams.Add(smithy.NewErrParamRequired("Arn"))
}
if v.ExecutionRoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ExecutionRoleArn"))
}
if v.OutputConfig == nil {
invalidParams.Add(smithy.NewErrParamRequired("OutputConfig"))
} else if v.OutputConfig != nil {
if err := validateOutputConfigInput(v.OutputConfig); err != nil {
invalidParams.AddNested("OutputConfig", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpExportVectorEnrichmentJobInput(v *ExportVectorEnrichmentJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ExportVectorEnrichmentJobInput"}
if v.Arn == nil {
invalidParams.Add(smithy.NewErrParamRequired("Arn"))
}
if v.ExecutionRoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ExecutionRoleArn"))
}
if v.OutputConfig == nil {
invalidParams.Add(smithy.NewErrParamRequired("OutputConfig"))
} else if v.OutputConfig != nil {
if err := validateExportVectorEnrichmentJobOutputConfig(v.OutputConfig); err != nil {
invalidParams.AddNested("OutputConfig", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetEarthObservationJobInput(v *GetEarthObservationJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetEarthObservationJobInput"}
if v.Arn == nil {
invalidParams.Add(smithy.NewErrParamRequired("Arn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetRasterDataCollectionInput(v *GetRasterDataCollectionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetRasterDataCollectionInput"}
if v.Arn == nil {
invalidParams.Add(smithy.NewErrParamRequired("Arn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetTileInput(v *GetTileInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetTileInput"}
if v.X == nil {
invalidParams.Add(smithy.NewErrParamRequired("X"))
}
if v.Y == nil {
invalidParams.Add(smithy.NewErrParamRequired("Y"))
}
if v.Z == nil {
invalidParams.Add(smithy.NewErrParamRequired("Z"))
}
if v.ImageAssets == nil {
invalidParams.Add(smithy.NewErrParamRequired("ImageAssets"))
}
if len(v.Target) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Target"))
}
if v.Arn == nil {
invalidParams.Add(smithy.NewErrParamRequired("Arn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetVectorEnrichmentJobInput(v *GetVectorEnrichmentJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetVectorEnrichmentJobInput"}
if v.Arn == nil {
invalidParams.Add(smithy.NewErrParamRequired("Arn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpSearchRasterDataCollectionInput(v *SearchRasterDataCollectionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SearchRasterDataCollectionInput"}
if v.Arn == nil {
invalidParams.Add(smithy.NewErrParamRequired("Arn"))
}
if v.RasterDataCollectionQuery == nil {
invalidParams.Add(smithy.NewErrParamRequired("RasterDataCollectionQuery"))
} else if v.RasterDataCollectionQuery != nil {
if err := validateRasterDataCollectionQueryWithBandFilterInput(v.RasterDataCollectionQuery); err != nil {
invalidParams.AddNested("RasterDataCollectionQuery", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartEarthObservationJobInput(v *StartEarthObservationJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartEarthObservationJobInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.InputConfig == nil {
invalidParams.Add(smithy.NewErrParamRequired("InputConfig"))
} else if v.InputConfig != nil {
if err := validateInputConfigInput(v.InputConfig); err != nil {
invalidParams.AddNested("InputConfig", err.(smithy.InvalidParamsError))
}
}
if v.JobConfig == nil {
invalidParams.Add(smithy.NewErrParamRequired("JobConfig"))
} else if v.JobConfig != nil {
if err := validateJobConfigInput(v.JobConfig); err != nil {
invalidParams.AddNested("JobConfig", err.(smithy.InvalidParamsError))
}
}
if v.ExecutionRoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ExecutionRoleArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartVectorEnrichmentJobInput(v *StartVectorEnrichmentJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartVectorEnrichmentJobInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.InputConfig == nil {
invalidParams.Add(smithy.NewErrParamRequired("InputConfig"))
} else if v.InputConfig != nil {
if err := validateVectorEnrichmentJobInputConfig(v.InputConfig); err != nil {
invalidParams.AddNested("InputConfig", err.(smithy.InvalidParamsError))
}
}
if v.JobConfig == nil {
invalidParams.Add(smithy.NewErrParamRequired("JobConfig"))
} else if v.JobConfig != nil {
if err := validateVectorEnrichmentJobConfig(v.JobConfig); err != nil {
invalidParams.AddNested("JobConfig", err.(smithy.InvalidParamsError))
}
}
if v.ExecutionRoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ExecutionRoleArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStopEarthObservationJobInput(v *StopEarthObservationJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StopEarthObservationJobInput"}
if v.Arn == nil {
invalidParams.Add(smithy.NewErrParamRequired("Arn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStopVectorEnrichmentJobInput(v *StopVectorEnrichmentJobInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StopVectorEnrichmentJobInput"}
if v.Arn == nil {
invalidParams.Add(smithy.NewErrParamRequired("Arn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpTagResourceInput(v *TagResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if v.Tags == nil {
invalidParams.Add(smithy.NewErrParamRequired("Tags"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUntagResourceInput(v *UntagResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if v.TagKeys == nil {
invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 1,495 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"github.com/aws/aws-sdk-go-v2/aws"
endpoints "github.com/aws/aws-sdk-go-v2/internal/endpoints/v2"
"github.com/aws/smithy-go/logging"
"regexp"
)
// Options is the endpoint resolver configuration options
type Options struct {
// Logger is a logging implementation that log events should be sent to.
Logger logging.Logger
// LogDeprecated indicates that deprecated endpoints should be logged to the
// provided logger.
LogDeprecated bool
// ResolvedRegion is used to override the region to be resolved, rather then the
// using the value passed to the ResolveEndpoint method. This value is used by the
// SDK to translate regions like fips-us-east-1 or us-east-1-fips to an alternative
// name. You must not set this value directly in your application.
ResolvedRegion string
// DisableHTTPS informs the resolver to return an endpoint that does not use the
// HTTPS scheme.
DisableHTTPS bool
// UseDualStackEndpoint specifies the resolver must resolve a dual-stack endpoint.
UseDualStackEndpoint aws.DualStackEndpointState
// UseFIPSEndpoint specifies the resolver must resolve a FIPS endpoint.
UseFIPSEndpoint aws.FIPSEndpointState
}
func (o Options) GetResolvedRegion() string {
return o.ResolvedRegion
}
func (o Options) GetDisableHTTPS() bool {
return o.DisableHTTPS
}
func (o Options) GetUseDualStackEndpoint() aws.DualStackEndpointState {
return o.UseDualStackEndpoint
}
func (o Options) GetUseFIPSEndpoint() aws.FIPSEndpointState {
return o.UseFIPSEndpoint
}
func transformToSharedOptions(options Options) endpoints.Options {
return endpoints.Options{
Logger: options.Logger,
LogDeprecated: options.LogDeprecated,
ResolvedRegion: options.ResolvedRegion,
DisableHTTPS: options.DisableHTTPS,
UseDualStackEndpoint: options.UseDualStackEndpoint,
UseFIPSEndpoint: options.UseFIPSEndpoint,
}
}
// Resolver SageMaker Geospatial endpoint resolver
type Resolver struct {
partitions endpoints.Partitions
}
// ResolveEndpoint resolves the service endpoint for the given region and options
func (r *Resolver) ResolveEndpoint(region string, options Options) (endpoint aws.Endpoint, err error) {
if len(region) == 0 {
return endpoint, &aws.MissingRegionError{}
}
opt := transformToSharedOptions(options)
return r.partitions.ResolveEndpoint(region, opt)
}
// New returns a new Resolver
func New() *Resolver {
return &Resolver{
partitions: defaultPartitions,
}
}
var partitionRegexp = struct {
Aws *regexp.Regexp
AwsCn *regexp.Regexp
AwsIso *regexp.Regexp
AwsIsoB *regexp.Regexp
AwsIsoE *regexp.Regexp
AwsIsoF *regexp.Regexp
AwsUsGov *regexp.Regexp
}{
Aws: regexp.MustCompile("^(us|eu|ap|sa|ca|me|af)\\-\\w+\\-\\d+$"),
AwsCn: regexp.MustCompile("^cn\\-\\w+\\-\\d+$"),
AwsIso: regexp.MustCompile("^us\\-iso\\-\\w+\\-\\d+$"),
AwsIsoB: regexp.MustCompile("^us\\-isob\\-\\w+\\-\\d+$"),
AwsIsoE: regexp.MustCompile("^eu\\-isoe\\-\\w+\\-\\d+$"),
AwsIsoF: regexp.MustCompile("^us\\-isof\\-\\w+\\-\\d+$"),
AwsUsGov: regexp.MustCompile("^us\\-gov\\-\\w+\\-\\d+$"),
}
var defaultPartitions = endpoints.Partitions{
{
ID: "aws",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "sagemaker-geospatial.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "sagemaker-geospatial-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "sagemaker-geospatial-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "sagemaker-geospatial.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.Aws,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "us-west-2",
}: endpoints.Endpoint{},
},
},
{
ID: "aws-cn",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "sagemaker-geospatial.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "sagemaker-geospatial-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "sagemaker-geospatial-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "sagemaker-geospatial.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsCn,
IsRegionalized: true,
},
{
ID: "aws-iso",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "sagemaker-geospatial-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "sagemaker-geospatial.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIso,
IsRegionalized: true,
},
{
ID: "aws-iso-b",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "sagemaker-geospatial-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "sagemaker-geospatial.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoB,
IsRegionalized: true,
},
{
ID: "aws-iso-e",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "sagemaker-geospatial-fips.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "sagemaker-geospatial.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoE,
IsRegionalized: true,
},
{
ID: "aws-iso-f",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "sagemaker-geospatial-fips.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "sagemaker-geospatial.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoF,
IsRegionalized: true,
},
{
ID: "aws-us-gov",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "sagemaker-geospatial.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "sagemaker-geospatial-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "sagemaker-geospatial-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "sagemaker-geospatial.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: true,
},
}
| 302 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"testing"
)
func TestRegexCompile(t *testing.T) {
_ = defaultPartitions
}
| 12 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
type AlgorithmNameCloudRemoval string
// Enum values for AlgorithmNameCloudRemoval
const (
// INTERPOLATION
AlgorithmNameCloudRemovalInterpolation AlgorithmNameCloudRemoval = "INTERPOLATION"
)
// Values returns all known values for AlgorithmNameCloudRemoval. 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 (AlgorithmNameCloudRemoval) Values() []AlgorithmNameCloudRemoval {
return []AlgorithmNameCloudRemoval{
"INTERPOLATION",
}
}
type AlgorithmNameGeoMosaic string
// Enum values for AlgorithmNameGeoMosaic
const (
// NEAR
AlgorithmNameGeoMosaicNear AlgorithmNameGeoMosaic = "NEAR"
// BILINEAR
AlgorithmNameGeoMosaicBilinear AlgorithmNameGeoMosaic = "BILINEAR"
// CUBIC
AlgorithmNameGeoMosaicCubic AlgorithmNameGeoMosaic = "CUBIC"
// CUBICSPLINE
AlgorithmNameGeoMosaicCubicspline AlgorithmNameGeoMosaic = "CUBICSPLINE"
// LANCZOS
AlgorithmNameGeoMosaicLanczos AlgorithmNameGeoMosaic = "LANCZOS"
// AVERAGE
AlgorithmNameGeoMosaicAverage AlgorithmNameGeoMosaic = "AVERAGE"
// RMS
AlgorithmNameGeoMosaicRms AlgorithmNameGeoMosaic = "RMS"
// MODE
AlgorithmNameGeoMosaicMode AlgorithmNameGeoMosaic = "MODE"
// MAX
AlgorithmNameGeoMosaicMax AlgorithmNameGeoMosaic = "MAX"
// MIN
AlgorithmNameGeoMosaicMin AlgorithmNameGeoMosaic = "MIN"
// MED
AlgorithmNameGeoMosaicMed AlgorithmNameGeoMosaic = "MED"
// Q1
AlgorithmNameGeoMosaicQ1 AlgorithmNameGeoMosaic = "Q1"
// Q3
AlgorithmNameGeoMosaicQ3 AlgorithmNameGeoMosaic = "Q3"
// SUM
AlgorithmNameGeoMosaicSum AlgorithmNameGeoMosaic = "SUM"
)
// Values returns all known values for AlgorithmNameGeoMosaic. 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 (AlgorithmNameGeoMosaic) Values() []AlgorithmNameGeoMosaic {
return []AlgorithmNameGeoMosaic{
"NEAR",
"BILINEAR",
"CUBIC",
"CUBICSPLINE",
"LANCZOS",
"AVERAGE",
"RMS",
"MODE",
"MAX",
"MIN",
"MED",
"Q1",
"Q3",
"SUM",
}
}
type AlgorithmNameResampling string
// Enum values for AlgorithmNameResampling
const (
// NEAR
AlgorithmNameResamplingNear AlgorithmNameResampling = "NEAR"
// BILINEAR
AlgorithmNameResamplingBilinear AlgorithmNameResampling = "BILINEAR"
// CUBIC
AlgorithmNameResamplingCubic AlgorithmNameResampling = "CUBIC"
// CUBICSPLINE
AlgorithmNameResamplingCubicspline AlgorithmNameResampling = "CUBICSPLINE"
// LANCZOS
AlgorithmNameResamplingLanczos AlgorithmNameResampling = "LANCZOS"
// AVERAGE
AlgorithmNameResamplingAverage AlgorithmNameResampling = "AVERAGE"
// RMS
AlgorithmNameResamplingRms AlgorithmNameResampling = "RMS"
// MODE
AlgorithmNameResamplingMode AlgorithmNameResampling = "MODE"
// MAX
AlgorithmNameResamplingMax AlgorithmNameResampling = "MAX"
// MIN
AlgorithmNameResamplingMin AlgorithmNameResampling = "MIN"
// MED
AlgorithmNameResamplingMed AlgorithmNameResampling = "MED"
// Q1
AlgorithmNameResamplingQ1 AlgorithmNameResampling = "Q1"
// Q3
AlgorithmNameResamplingQ3 AlgorithmNameResampling = "Q3"
// SUM
AlgorithmNameResamplingSum AlgorithmNameResampling = "SUM"
)
// Values returns all known values for AlgorithmNameResampling. 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 (AlgorithmNameResampling) Values() []AlgorithmNameResampling {
return []AlgorithmNameResampling{
"NEAR",
"BILINEAR",
"CUBIC",
"CUBICSPLINE",
"LANCZOS",
"AVERAGE",
"RMS",
"MODE",
"MAX",
"MIN",
"MED",
"Q1",
"Q3",
"SUM",
}
}
type ComparisonOperator string
// Enum values for ComparisonOperator
const (
// EQUALS
ComparisonOperatorEquals ComparisonOperator = "EQUALS"
// NOT_EQUALS
ComparisonOperatorNotEquals ComparisonOperator = "NOT_EQUALS"
// STARTS_WITH
ComparisonOperatorStartsWith ComparisonOperator = "STARTS_WITH"
)
// Values returns all known values for ComparisonOperator. 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 (ComparisonOperator) Values() []ComparisonOperator {
return []ComparisonOperator{
"EQUALS",
"NOT_EQUALS",
"STARTS_WITH",
}
}
type DataCollectionType string
// Enum values for DataCollectionType
const (
// PUBLIC
DataCollectionTypePublic DataCollectionType = "PUBLIC"
// PREMIUM
DataCollectionTypePremium DataCollectionType = "PREMIUM"
// USER
DataCollectionTypeUser DataCollectionType = "USER"
)
// Values returns all known values for DataCollectionType. 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 (DataCollectionType) Values() []DataCollectionType {
return []DataCollectionType{
"PUBLIC",
"PREMIUM",
"USER",
}
}
type EarthObservationJobErrorType string
// Enum values for EarthObservationJobErrorType
const (
// CLIENT_ERROR
EarthObservationJobErrorTypeClientError EarthObservationJobErrorType = "CLIENT_ERROR"
// SERVER_ERROR
EarthObservationJobErrorTypeServerError EarthObservationJobErrorType = "SERVER_ERROR"
)
// Values returns all known values for EarthObservationJobErrorType. 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 (EarthObservationJobErrorType) Values() []EarthObservationJobErrorType {
return []EarthObservationJobErrorType{
"CLIENT_ERROR",
"SERVER_ERROR",
}
}
type EarthObservationJobExportStatus string
// Enum values for EarthObservationJobExportStatus
const (
// IN_PROGRESS
EarthObservationJobExportStatusInProgress EarthObservationJobExportStatus = "IN_PROGRESS"
// SUCCEEDED
EarthObservationJobExportStatusSucceeded EarthObservationJobExportStatus = "SUCCEEDED"
// FAILED
EarthObservationJobExportStatusFailed EarthObservationJobExportStatus = "FAILED"
)
// Values returns all known values for EarthObservationJobExportStatus. 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 (EarthObservationJobExportStatus) Values() []EarthObservationJobExportStatus {
return []EarthObservationJobExportStatus{
"IN_PROGRESS",
"SUCCEEDED",
"FAILED",
}
}
type EarthObservationJobStatus string
// Enum values for EarthObservationJobStatus
const (
// INITIALIZING
EarthObservationJobStatusInitializing EarthObservationJobStatus = "INITIALIZING"
// IN_PROGRESS
EarthObservationJobStatusInProgress EarthObservationJobStatus = "IN_PROGRESS"
// STOPPING
EarthObservationJobStatusStopping EarthObservationJobStatus = "STOPPING"
// COMPLETED
EarthObservationJobStatusCompleted EarthObservationJobStatus = "COMPLETED"
// STOPPED
EarthObservationJobStatusStopped EarthObservationJobStatus = "STOPPED"
// FAILED
EarthObservationJobStatusFailed EarthObservationJobStatus = "FAILED"
// DELETING
EarthObservationJobStatusDeleting EarthObservationJobStatus = "DELETING"
// DELETED
EarthObservationJobStatusDeleted EarthObservationJobStatus = "DELETED"
)
// Values returns all known values for EarthObservationJobStatus. 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 (EarthObservationJobStatus) Values() []EarthObservationJobStatus {
return []EarthObservationJobStatus{
"INITIALIZING",
"IN_PROGRESS",
"STOPPING",
"COMPLETED",
"STOPPED",
"FAILED",
"DELETING",
"DELETED",
}
}
type ExportErrorType string
// Enum values for ExportErrorType
const (
// CLIENT_ERROR
ExportErrorTypeClientError ExportErrorType = "CLIENT_ERROR"
// SERVER_ERROR
ExportErrorTypeServerError ExportErrorType = "SERVER_ERROR"
)
// Values returns all known values for ExportErrorType. 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 (ExportErrorType) Values() []ExportErrorType {
return []ExportErrorType{
"CLIENT_ERROR",
"SERVER_ERROR",
}
}
type GroupBy string
// Enum values for GroupBy
const (
// ALL
GroupByAll GroupBy = "ALL"
// YEARLY
GroupByYearly GroupBy = "YEARLY"
)
// Values returns all known values for GroupBy. 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 (GroupBy) Values() []GroupBy {
return []GroupBy{
"ALL",
"YEARLY",
}
}
type LogicalOperator string
// Enum values for LogicalOperator
const (
// AND
LogicalOperatorAnd LogicalOperator = "AND"
)
// Values returns all known values for LogicalOperator. 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 (LogicalOperator) Values() []LogicalOperator {
return []LogicalOperator{
"AND",
}
}
type OutputType string
// Enum values for OutputType
const (
// INT32
OutputTypeInt32 OutputType = "INT32"
// FLOAT32
OutputTypeFloat32 OutputType = "FLOAT32"
// INT16
OutputTypeInt16 OutputType = "INT16"
// FLOAT64
OutputTypeFloat64 OutputType = "FLOAT64"
// UINT16
OutputTypeUint16 OutputType = "UINT16"
)
// Values returns all known values for OutputType. 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 (OutputType) Values() []OutputType {
return []OutputType{
"INT32",
"FLOAT32",
"INT16",
"FLOAT64",
"UINT16",
}
}
type PredefinedResolution string
// Enum values for PredefinedResolution
const (
// HIGHEST
PredefinedResolutionHighest PredefinedResolution = "HIGHEST"
// LOWEST
PredefinedResolutionLowest PredefinedResolution = "LOWEST"
// AVERAGE
PredefinedResolutionAverage PredefinedResolution = "AVERAGE"
)
// Values returns all known values for PredefinedResolution. 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 (PredefinedResolution) Values() []PredefinedResolution {
return []PredefinedResolution{
"HIGHEST",
"LOWEST",
"AVERAGE",
}
}
type SortOrder string
// Enum values for SortOrder
const (
// ASCENDING
SortOrderAscending SortOrder = "ASCENDING"
// DESCENDING
SortOrderDescending SortOrder = "DESCENDING"
)
// Values returns all known values for SortOrder. 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 (SortOrder) Values() []SortOrder {
return []SortOrder{
"ASCENDING",
"DESCENDING",
}
}
type TargetOptions string
// Enum values for TargetOptions
const (
// INPUT
TargetOptionsInput TargetOptions = "INPUT"
// OUTPUT
TargetOptionsOutput TargetOptions = "OUTPUT"
)
// Values returns all known values for TargetOptions. 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 (TargetOptions) Values() []TargetOptions {
return []TargetOptions{
"INPUT",
"OUTPUT",
}
}
type TemporalStatistics string
// Enum values for TemporalStatistics
const (
// MEAN
TemporalStatisticsMean TemporalStatistics = "MEAN"
// MEDIAN
TemporalStatisticsMedian TemporalStatistics = "MEDIAN"
// STANDARD_DEVIATION
TemporalStatisticsStandardDeviation TemporalStatistics = "STANDARD_DEVIATION"
)
// Values returns all known values for TemporalStatistics. 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 (TemporalStatistics) Values() []TemporalStatistics {
return []TemporalStatistics{
"MEAN",
"MEDIAN",
"STANDARD_DEVIATION",
}
}
type Unit string
// Enum values for Unit
const (
// METERS
UnitMeters Unit = "METERS"
)
// Values returns all known values for Unit. 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 (Unit) Values() []Unit {
return []Unit{
"METERS",
}
}
type VectorEnrichmentJobDocumentType string
// Enum values for VectorEnrichmentJobDocumentType
const (
VectorEnrichmentJobDocumentTypeCsv VectorEnrichmentJobDocumentType = "CSV"
)
// Values returns all known values for VectorEnrichmentJobDocumentType. 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 (VectorEnrichmentJobDocumentType) Values() []VectorEnrichmentJobDocumentType {
return []VectorEnrichmentJobDocumentType{
"CSV",
}
}
type VectorEnrichmentJobErrorType string
// Enum values for VectorEnrichmentJobErrorType
const (
// CLIENT_ERROR
VectorEnrichmentJobErrorTypeClientError VectorEnrichmentJobErrorType = "CLIENT_ERROR"
// SERVER_ERROR
VectorEnrichmentJobErrorTypeServerError VectorEnrichmentJobErrorType = "SERVER_ERROR"
)
// Values returns all known values for VectorEnrichmentJobErrorType. 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 (VectorEnrichmentJobErrorType) Values() []VectorEnrichmentJobErrorType {
return []VectorEnrichmentJobErrorType{
"CLIENT_ERROR",
"SERVER_ERROR",
}
}
type VectorEnrichmentJobExportErrorType string
// Enum values for VectorEnrichmentJobExportErrorType
const (
VectorEnrichmentJobExportErrorTypeClientError VectorEnrichmentJobExportErrorType = "CLIENT_ERROR"
VectorEnrichmentJobExportErrorTypeServerError VectorEnrichmentJobExportErrorType = "SERVER_ERROR"
)
// Values returns all known values for VectorEnrichmentJobExportErrorType. 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 (VectorEnrichmentJobExportErrorType) Values() []VectorEnrichmentJobExportErrorType {
return []VectorEnrichmentJobExportErrorType{
"CLIENT_ERROR",
"SERVER_ERROR",
}
}
type VectorEnrichmentJobExportStatus string
// Enum values for VectorEnrichmentJobExportStatus
const (
VectorEnrichmentJobExportStatusInProgress VectorEnrichmentJobExportStatus = "IN_PROGRESS"
VectorEnrichmentJobExportStatusSucceeded VectorEnrichmentJobExportStatus = "SUCCEEDED"
VectorEnrichmentJobExportStatusFailed VectorEnrichmentJobExportStatus = "FAILED"
)
// Values returns all known values for VectorEnrichmentJobExportStatus. 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 (VectorEnrichmentJobExportStatus) Values() []VectorEnrichmentJobExportStatus {
return []VectorEnrichmentJobExportStatus{
"IN_PROGRESS",
"SUCCEEDED",
"FAILED",
}
}
type VectorEnrichmentJobStatus string
// Enum values for VectorEnrichmentJobStatus
const (
VectorEnrichmentJobStatusInitializing VectorEnrichmentJobStatus = "INITIALIZING"
VectorEnrichmentJobStatusInProgress VectorEnrichmentJobStatus = "IN_PROGRESS"
VectorEnrichmentJobStatusStopping VectorEnrichmentJobStatus = "STOPPING"
VectorEnrichmentJobStatusStopped VectorEnrichmentJobStatus = "STOPPED"
VectorEnrichmentJobStatusCompleted VectorEnrichmentJobStatus = "COMPLETED"
VectorEnrichmentJobStatusFailed VectorEnrichmentJobStatus = "FAILED"
VectorEnrichmentJobStatusDeleting VectorEnrichmentJobStatus = "DELETING"
VectorEnrichmentJobStatusDeleted VectorEnrichmentJobStatus = "DELETED"
)
// Values returns all known values for VectorEnrichmentJobStatus. 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 (VectorEnrichmentJobStatus) Values() []VectorEnrichmentJobStatus {
return []VectorEnrichmentJobStatus{
"INITIALIZING",
"IN_PROGRESS",
"STOPPING",
"STOPPED",
"COMPLETED",
"FAILED",
"DELETING",
"DELETED",
}
}
type VectorEnrichmentJobType string
// Enum values for VectorEnrichmentJobType
const (
VectorEnrichmentJobTypeReverseGeocoding VectorEnrichmentJobType = "REVERSE_GEOCODING"
VectorEnrichmentJobTypeMapMatching VectorEnrichmentJobType = "MAP_MATCHING"
)
// Values returns all known values for VectorEnrichmentJobType. 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 (VectorEnrichmentJobType) Values() []VectorEnrichmentJobType {
return []VectorEnrichmentJobType{
"REVERSE_GEOCODING",
"MAP_MATCHING",
}
}
type ZonalStatistics string
// Enum values for ZonalStatistics
const (
// MEAN
ZonalStatisticsMean ZonalStatistics = "MEAN"
// MEDIAN
ZonalStatisticsMedian ZonalStatistics = "MEDIAN"
// STANDARD_DEVIATION
ZonalStatisticsStandardDeviation ZonalStatistics = "STANDARD_DEVIATION"
// MAX
ZonalStatisticsMax ZonalStatistics = "MAX"
// MIN
ZonalStatisticsMin ZonalStatistics = "MIN"
// SUM
ZonalStatisticsSum ZonalStatistics = "SUM"
)
// Values returns all known values for ZonalStatistics. 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 (ZonalStatistics) Values() []ZonalStatistics {
return []ZonalStatistics{
"MEAN",
"MEDIAN",
"STANDARD_DEVIATION",
"MAX",
"MIN",
"SUM",
}
}
| 609 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
"fmt"
smithy "github.com/aws/smithy-go"
)
// You do not have sufficient access to perform this action.
type AccessDeniedException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *AccessDeniedException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *AccessDeniedException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *AccessDeniedException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "AccessDeniedException"
}
return *e.ErrorCodeOverride
}
func (e *AccessDeniedException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// Updating or deleting a resource can cause an inconsistent state.
type ConflictException struct {
Message *string
ErrorCodeOverride *string
ResourceId *string
noSmithyDocumentSerde
}
func (e *ConflictException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ConflictException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ConflictException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ConflictException"
}
return *e.ErrorCodeOverride
}
func (e *ConflictException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The request processing has failed because of an unknown error, exception, or
// failure.
type InternalServerException struct {
Message *string
ErrorCodeOverride *string
ResourceId *string
noSmithyDocumentSerde
}
func (e *InternalServerException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InternalServerException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InternalServerException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InternalServerException"
}
return *e.ErrorCodeOverride
}
func (e *InternalServerException) ErrorFault() smithy.ErrorFault { return smithy.FaultServer }
// The request references a resource which does not exist.
type ResourceNotFoundException struct {
Message *string
ErrorCodeOverride *string
ResourceId *string
noSmithyDocumentSerde
}
func (e *ResourceNotFoundException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ResourceNotFoundException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ResourceNotFoundException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ResourceNotFoundException"
}
return *e.ErrorCodeOverride
}
func (e *ResourceNotFoundException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// You have exceeded the service quota.
type ServiceQuotaExceededException struct {
Message *string
ErrorCodeOverride *string
ResourceId *string
noSmithyDocumentSerde
}
func (e *ServiceQuotaExceededException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ServiceQuotaExceededException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ServiceQuotaExceededException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ServiceQuotaExceededException"
}
return *e.ErrorCodeOverride
}
func (e *ServiceQuotaExceededException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The request was denied due to request throttling.
type ThrottlingException struct {
Message *string
ErrorCodeOverride *string
ResourceId *string
noSmithyDocumentSerde
}
func (e *ThrottlingException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ThrottlingException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ThrottlingException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ThrottlingException"
}
return *e.ErrorCodeOverride
}
func (e *ThrottlingException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The input fails to satisfy the constraints specified by an Amazon Web Services
// service.
type ValidationException struct {
Message *string
ErrorCodeOverride *string
ResourceId *string
noSmithyDocumentSerde
}
func (e *ValidationException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ValidationException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ValidationException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ValidationException"
}
return *e.ErrorCodeOverride
}
func (e *ValidationException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
| 205 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
smithydocument "github.com/aws/smithy-go/document"
"time"
)
// The geographic extent of the Earth Observation job.
//
// The following types satisfy this interface:
//
// AreaOfInterestMemberAreaOfInterestGeometry
type AreaOfInterest interface {
isAreaOfInterest()
}
// A GeoJSON object representing the geographic extent in the coordinate space.
type AreaOfInterestMemberAreaOfInterestGeometry struct {
Value AreaOfInterestGeometry
noSmithyDocumentSerde
}
func (*AreaOfInterestMemberAreaOfInterestGeometry) isAreaOfInterest() {}
// A GeoJSON object representing the geographic extent in the coordinate space.
//
// The following types satisfy this interface:
//
// AreaOfInterestGeometryMemberMultiPolygonGeometry
// AreaOfInterestGeometryMemberPolygonGeometry
type AreaOfInterestGeometry interface {
isAreaOfInterestGeometry()
}
// The structure representing the MultiPolygon Geometry.
type AreaOfInterestGeometryMemberMultiPolygonGeometry struct {
Value MultiPolygonGeometryInput
noSmithyDocumentSerde
}
func (*AreaOfInterestGeometryMemberMultiPolygonGeometry) isAreaOfInterestGeometry() {}
// The structure representing Polygon Geometry.
type AreaOfInterestGeometryMemberPolygonGeometry struct {
Value PolygonGeometryInput
noSmithyDocumentSerde
}
func (*AreaOfInterestGeometryMemberPolygonGeometry) isAreaOfInterestGeometry() {}
// The structure containing the asset properties.
type AssetValue struct {
// Link to the asset object.
Href *string
noSmithyDocumentSerde
}
// Input structure for the BandMath operation type. Defines Predefined and
// CustomIndices to be computed using BandMath.
type BandMathConfigInput struct {
// CustomIndices that are computed.
CustomIndices *CustomIndicesInput
// One or many of the supported predefined indices to compute. Allowed values: NDVI
// , EVI2 , MSAVI , NDWI , NDMI , NDSI , and WDRVI .
PredefinedIndices []string
noSmithyDocumentSerde
}
// Input structure for CloudMasking operation type.
type CloudMaskingConfigInput struct {
noSmithyDocumentSerde
}
// Input structure for Cloud Removal Operation type
type CloudRemovalConfigInput struct {
// The name of the algorithm used for cloud removal.
AlgorithmName AlgorithmNameCloudRemoval
// The interpolation value you provide for cloud removal.
InterpolationValue *string
// TargetBands to be returned in the output of CloudRemoval operation.
TargetBands []string
noSmithyDocumentSerde
}
// Input object defining the custom BandMath indices to compute.
type CustomIndicesInput struct {
// A list of BandMath indices to compute.
Operations []Operation
noSmithyDocumentSerde
}
// The structure representing the errors in an EarthObservationJob.
type EarthObservationJobErrorDetails struct {
// A detailed message describing the error in an Earth Observation job.
Message *string
// The type of error in an Earth Observation job.
Type EarthObservationJobErrorType
noSmithyDocumentSerde
}
// The structure representing the EoCloudCover filter.
type EoCloudCoverInput struct {
// Lower bound for EoCloudCover.
//
// This member is required.
LowerBound *float32
// Upper bound for EoCloudCover.
//
// This member is required.
UpperBound *float32
noSmithyDocumentSerde
}
// The structure for returning the export error details in a
// GetEarthObservationJob.
type ExportErrorDetails struct {
// The structure for returning the export error details while exporting results of
// an Earth Observation job.
ExportResults *ExportErrorDetailsOutput
// The structure for returning the export error details while exporting the source
// images of an Earth Observation job.
ExportSourceImages *ExportErrorDetailsOutput
noSmithyDocumentSerde
}
// The structure representing the errors in an export EarthObservationJob
// operation.
type ExportErrorDetailsOutput struct {
// A detailed message describing the error in an export EarthObservationJob
// operation.
Message *string
// The type of error in an export EarthObservationJob operation.
Type ExportErrorType
noSmithyDocumentSerde
}
// The structure containing the Amazon S3 path to export the Earth Observation job
// output.
type ExportS3DataInput struct {
// The URL to the Amazon S3 data input.
//
// This member is required.
S3Uri *string
// The Key Management Service key ID for server-side encryption.
KmsKeyId *string
noSmithyDocumentSerde
}
// An object containing information about the output file.
type ExportVectorEnrichmentJobOutputConfig struct {
// The input structure for Amazon S3 data; representing the Amazon S3 location of
// the input data objects.
//
// This member is required.
S3Data *VectorEnrichmentJobS3Data
noSmithyDocumentSerde
}
// The structure representing the filters supported by a RasterDataCollection.
type Filter struct {
// The name of the filter.
//
// This member is required.
Name *string
// The type of the filter being used.
//
// This member is required.
Type *string
// The maximum value of the filter.
Maximum *float32
// The minimum value of the filter.
Minimum *float32
noSmithyDocumentSerde
}
// The structure representing a Geometry in terms of Type and Coordinates as per
// GeoJson spec.
type Geometry struct {
// The coordinates of the GeoJson Geometry.
//
// This member is required.
Coordinates [][][]float64
// GeoJson Geometry types like Polygon and MultiPolygon.
//
// This member is required.
Type *string
noSmithyDocumentSerde
}
// Input configuration information for the geomosaic.
type GeoMosaicConfigInput struct {
// The name of the algorithm being used for geomosaic.
AlgorithmName AlgorithmNameGeoMosaic
// The target bands for geomosaic.
TargetBands []string
noSmithyDocumentSerde
}
// Input configuration information.
type InputConfigInput struct {
// The Amazon Resource Name (ARN) of the previous Earth Observation job.
PreviousEarthObservationJobArn *string
// The structure representing the RasterDataCollection Query consisting of the
// Area of Interest, RasterDataCollectionArn,TimeRange and Property Filters.
RasterDataCollectionQuery *RasterDataCollectionQueryInput
noSmithyDocumentSerde
}
// The InputConfig for an EarthObservationJob response.
type InputConfigOutput struct {
// The Amazon Resource Name (ARN) of the previous Earth Observation job.
PreviousEarthObservationJobArn *string
// The structure representing the RasterDataCollection Query consisting of the
// Area of Interest, RasterDataCollectionArn, RasterDataCollectionName, TimeRange,
// and Property Filters.
RasterDataCollectionQuery *RasterDataCollectionQueryOutput
noSmithyDocumentSerde
}
// The structure representing the items in the response for
// SearchRasterDataCollection.
type ItemSource struct {
// The searchable date and time of the item, in UTC.
//
// This member is required.
DateTime *time.Time
// The item Geometry in GeoJson format.
//
// This member is required.
Geometry *Geometry
// A unique Id for the source item.
//
// This member is required.
Id *string
// This is a dictionary of Asset Objects data associated with the Item that can be
// downloaded or streamed, each with a unique key.
Assets map[string]AssetValue
// This field contains additional properties of the item.
Properties *Properties
noSmithyDocumentSerde
}
// The input structure for the JobConfig in an EarthObservationJob.
//
// The following types satisfy this interface:
//
// JobConfigInputMemberBandMathConfig
// JobConfigInputMemberCloudMaskingConfig
// JobConfigInputMemberCloudRemovalConfig
// JobConfigInputMemberGeoMosaicConfig
// JobConfigInputMemberLandCoverSegmentationConfig
// JobConfigInputMemberResamplingConfig
// JobConfigInputMemberStackConfig
// JobConfigInputMemberTemporalStatisticsConfig
// JobConfigInputMemberZonalStatisticsConfig
type JobConfigInput interface {
isJobConfigInput()
}
// An object containing information about the job configuration for BandMath.
type JobConfigInputMemberBandMathConfig struct {
Value BandMathConfigInput
noSmithyDocumentSerde
}
func (*JobConfigInputMemberBandMathConfig) isJobConfigInput() {}
// An object containing information about the job configuration for cloud masking.
type JobConfigInputMemberCloudMaskingConfig struct {
Value CloudMaskingConfigInput
noSmithyDocumentSerde
}
func (*JobConfigInputMemberCloudMaskingConfig) isJobConfigInput() {}
// An object containing information about the job configuration for cloud removal.
type JobConfigInputMemberCloudRemovalConfig struct {
Value CloudRemovalConfigInput
noSmithyDocumentSerde
}
func (*JobConfigInputMemberCloudRemovalConfig) isJobConfigInput() {}
// An object containing information about the job configuration for geomosaic.
type JobConfigInputMemberGeoMosaicConfig struct {
Value GeoMosaicConfigInput
noSmithyDocumentSerde
}
func (*JobConfigInputMemberGeoMosaicConfig) isJobConfigInput() {}
// An object containing information about the job configuration for land cover
// segmentation.
type JobConfigInputMemberLandCoverSegmentationConfig struct {
Value LandCoverSegmentationConfigInput
noSmithyDocumentSerde
}
func (*JobConfigInputMemberLandCoverSegmentationConfig) isJobConfigInput() {}
// An object containing information about the job configuration for resampling.
type JobConfigInputMemberResamplingConfig struct {
Value ResamplingConfigInput
noSmithyDocumentSerde
}
func (*JobConfigInputMemberResamplingConfig) isJobConfigInput() {}
// An object containing information about the job configuration for a Stacking
// Earth Observation job.
type JobConfigInputMemberStackConfig struct {
Value StackConfigInput
noSmithyDocumentSerde
}
func (*JobConfigInputMemberStackConfig) isJobConfigInput() {}
// An object containing information about the job configuration for temporal
// statistics.
type JobConfigInputMemberTemporalStatisticsConfig struct {
Value TemporalStatisticsConfigInput
noSmithyDocumentSerde
}
func (*JobConfigInputMemberTemporalStatisticsConfig) isJobConfigInput() {}
// An object containing information about the job configuration for zonal
// statistics.
type JobConfigInputMemberZonalStatisticsConfig struct {
Value ZonalStatisticsConfigInput
noSmithyDocumentSerde
}
func (*JobConfigInputMemberZonalStatisticsConfig) isJobConfigInput() {}
// The input structure for Land Cover Operation type.
type LandCoverSegmentationConfigInput struct {
noSmithyDocumentSerde
}
// The structure representing Land Cloud Cover property for Landsat data
// collection.
type LandsatCloudCoverLandInput struct {
// The minimum value for Land Cloud Cover property filter. This will filter items
// having Land Cloud Cover greater than or equal to this value.
//
// This member is required.
LowerBound *float32
// The maximum value for Land Cloud Cover property filter. This will filter items
// having Land Cloud Cover less than or equal to this value.
//
// This member is required.
UpperBound *float32
noSmithyDocumentSerde
}
// An object containing information about the output file.
type ListEarthObservationJobOutputConfig struct {
// The Amazon Resource Name (ARN) of the list of the Earth Observation jobs.
//
// This member is required.
Arn *string
// The creation time.
//
// This member is required.
CreationTime *time.Time
// The duration of the session, in seconds.
//
// This member is required.
DurationInSeconds *int32
// The names of the Earth Observation jobs in the list.
//
// This member is required.
Name *string
// The operation type for an Earth Observation job.
//
// This member is required.
OperationType *string
// The status of the list of the Earth Observation jobs.
//
// This member is required.
Status EarthObservationJobStatus
// Each tag consists of a key and a value.
Tags map[string]string
noSmithyDocumentSerde
}
// An object containing information about the output file.
type ListVectorEnrichmentJobOutputConfig struct {
// The Amazon Resource Name (ARN) of the list of the Vector Enrichment jobs.
//
// This member is required.
Arn *string
// The creation time.
//
// This member is required.
CreationTime *time.Time
// The duration of the session, in seconds.
//
// This member is required.
DurationInSeconds *int32
// The names of the Vector Enrichment jobs in the list.
//
// This member is required.
Name *string
// The status of the Vector Enrichment jobs list.
//
// This member is required.
Status VectorEnrichmentJobStatus
// The type of the list of Vector Enrichment jobs.
//
// This member is required.
Type VectorEnrichmentJobType
// Each tag consists of a key and a value.
Tags map[string]string
noSmithyDocumentSerde
}
// The input structure for Map Matching operation type.
type MapMatchingConfig struct {
// The field name for the data that describes the identifier representing a
// collection of GPS points belonging to an individual trace.
//
// This member is required.
IdAttributeName *string
// The name of the timestamp attribute.
//
// This member is required.
TimestampAttributeName *string
// The name of the X-attribute
//
// This member is required.
XAttributeName *string
// The name of the Y-attribute
//
// This member is required.
YAttributeName *string
noSmithyDocumentSerde
}
// The structure representing Polygon Geometry based on the GeoJson spec (https://www.rfc-editor.org/rfc/rfc7946#section-3.1.6)
// .
type MultiPolygonGeometryInput struct {
// The coordinates of the multipolygon geometry.
//
// This member is required.
Coordinates [][][][]float64
noSmithyDocumentSerde
}
// Represents an arithmetic operation to compute spectral index.
type Operation struct {
// Textual representation of the math operation; Equation used to compute the
// spectral index.
//
// This member is required.
Equation *string
// The name of the operation.
//
// This member is required.
Name *string
// The type of the operation.
OutputType OutputType
noSmithyDocumentSerde
}
// A single EarthObservationJob output band.
type OutputBand struct {
// The name of the band.
//
// This member is required.
BandName *string
// The datatype of the output band.
//
// This member is required.
OutputDataType OutputType
noSmithyDocumentSerde
}
// The response structure for an OutputConfig returned by an
// ExportEarthObservationJob.
type OutputConfigInput struct {
// Path to Amazon S3 storage location for the output configuration file.
//
// This member is required.
S3Data *ExportS3DataInput
noSmithyDocumentSerde
}
// OutputResolution Configuration indicating the target resolution for the output
// of Resampling operation.
type OutputResolutionResamplingInput struct {
// User Defined Resolution for the output of Resampling operation defined by value
// and unit.
//
// This member is required.
UserDefined *UserDefined
noSmithyDocumentSerde
}
// The input structure representing Output Resolution for Stacking Operation.
type OutputResolutionStackInput struct {
// A string value representing Predefined Output Resolution for a stacking
// operation. Allowed values are HIGHEST , LOWEST , and AVERAGE .
Predefined PredefinedResolution
// The structure representing User Output Resolution for a Stacking operation
// defined as a value and unit.
UserDefined *UserDefined
noSmithyDocumentSerde
}
// The input structure for specifying Platform. Platform refers to the unique name
// of the specific platform the instrument is attached to. For satellites it is the
// name of the satellite, eg. landsat-8 (Landsat-8), sentinel-2a.
type PlatformInput struct {
// The value of the platform.
//
// This member is required.
Value *string
// The ComparisonOperator to use with PlatformInput.
ComparisonOperator ComparisonOperator
noSmithyDocumentSerde
}
// The structure representing Polygon Geometry based on the GeoJson spec (https://www.rfc-editor.org/rfc/rfc7946#section-3.1.6)
// .
type PolygonGeometryInput struct {
// Coordinates representing a Polygon based on the GeoJson spec (https://www.rfc-editor.org/rfc/rfc7946#section-3.1.6)
// .
//
// This member is required.
Coordinates [][][]float64
noSmithyDocumentSerde
}
// Properties associated with the Item.
type Properties struct {
// Estimate of cloud cover.
EoCloudCover *float32
// Land cloud cover for Landsat Data Collection.
LandsatCloudCoverLand *float32
// Platform property. Platform refers to the unique name of the specific platform
// the instrument is attached to. For satellites it is the name of the satellite,
// eg. landsat-8 (Landsat-8), sentinel-2a.
Platform *string
// The angle from the sensor between nadir (straight down) and the scene center.
// Measured in degrees (0-90).
ViewOffNadir *float32
// The sun azimuth angle. From the scene center point on the ground, this is the
// angle between truth north and the sun. Measured clockwise in degrees (0-360).
ViewSunAzimuth *float32
// The sun elevation angle. The angle from the tangent of the scene center point
// to the sun. Measured from the horizon in degrees (-90-90). Negative values
// indicate the sun is below the horizon, e.g. sun elevation of -10° means the data
// was captured during nautical twilight (https://www.timeanddate.com/astronomy/different-types-twilight.html)
// .
ViewSunElevation *float32
noSmithyDocumentSerde
}
// Represents a single searchable property to search on.
//
// The following types satisfy this interface:
//
// PropertyMemberEoCloudCover
// PropertyMemberLandsatCloudCoverLand
// PropertyMemberPlatform
// PropertyMemberViewOffNadir
// PropertyMemberViewSunAzimuth
// PropertyMemberViewSunElevation
type Property interface {
isProperty()
}
// The structure representing EoCloudCover property filter containing a lower
// bound and upper bound.
type PropertyMemberEoCloudCover struct {
Value EoCloudCoverInput
noSmithyDocumentSerde
}
func (*PropertyMemberEoCloudCover) isProperty() {}
// The structure representing Land Cloud Cover property filter for Landsat
// collection containing a lower bound and upper bound.
type PropertyMemberLandsatCloudCoverLand struct {
Value LandsatCloudCoverLandInput
noSmithyDocumentSerde
}
func (*PropertyMemberLandsatCloudCoverLand) isProperty() {}
// The structure representing Platform property filter consisting of value and
// comparison operator.
type PropertyMemberPlatform struct {
Value PlatformInput
noSmithyDocumentSerde
}
func (*PropertyMemberPlatform) isProperty() {}
// The structure representing ViewOffNadir property filter containing a lower
// bound and upper bound.
type PropertyMemberViewOffNadir struct {
Value ViewOffNadirInput
noSmithyDocumentSerde
}
func (*PropertyMemberViewOffNadir) isProperty() {}
// The structure representing ViewSunAzimuth property filter containing a lower
// bound and upper bound.
type PropertyMemberViewSunAzimuth struct {
Value ViewSunAzimuthInput
noSmithyDocumentSerde
}
func (*PropertyMemberViewSunAzimuth) isProperty() {}
// The structure representing ViewSunElevation property filter containing a lower
// bound and upper bound.
type PropertyMemberViewSunElevation struct {
Value ViewSunElevationInput
noSmithyDocumentSerde
}
func (*PropertyMemberViewSunElevation) isProperty() {}
// The structure representing a single PropertyFilter.
type PropertyFilter struct {
// Represents a single property to match with when searching a raster data
// collection.
//
// This member is required.
Property Property
noSmithyDocumentSerde
}
// A list of PropertyFilter objects.
type PropertyFilters struct {
// The Logical Operator used to combine the Property Filters.
LogicalOperator LogicalOperator
// A list of Property Filters.
Properties []PropertyFilter
noSmithyDocumentSerde
}
// Response object containing details for a specific RasterDataCollection.
type RasterDataCollectionMetadata struct {
// The Amazon Resource Name (ARN) of the raster data collection.
//
// This member is required.
Arn *string
// A description of the raster data collection.
//
// This member is required.
Description *string
// The name of the raster data collection.
//
// This member is required.
Name *string
// The list of filters supported by the raster data collection.
//
// This member is required.
SupportedFilters []Filter
// The type of raster data collection.
//
// This member is required.
Type DataCollectionType
// The description URL of the raster data collection.
DescriptionPageUrl *string
// Each tag consists of a key and a value.
Tags map[string]string
noSmithyDocumentSerde
}
// The input structure for Raster Data Collection Query containing the Area of
// Interest, TimeRange Filters, and Property Filters.
type RasterDataCollectionQueryInput struct {
// The Amazon Resource Name (ARN) of the raster data collection.
//
// This member is required.
RasterDataCollectionArn *string
// The TimeRange Filter used in the RasterDataCollection Query.
//
// This member is required.
TimeRangeFilter *TimeRangeFilterInput
// The area of interest being queried for the raster data collection.
AreaOfInterest AreaOfInterest
// The list of Property filters used in the Raster Data Collection Query.
PropertyFilters *PropertyFilters
noSmithyDocumentSerde
}
// The output structure contains the Raster Data Collection Query input along with
// some additional metadata.
type RasterDataCollectionQueryOutput struct {
// The ARN of the Raster Data Collection against which the search is done.
//
// This member is required.
RasterDataCollectionArn *string
// The name of the raster data collection.
//
// This member is required.
RasterDataCollectionName *string
// The TimeRange filter used in the search.
//
// This member is required.
TimeRangeFilter *TimeRangeFilterOutput
// The Area of Interest used in the search.
AreaOfInterest AreaOfInterest
// Property filters used in the search.
PropertyFilters *PropertyFilters
noSmithyDocumentSerde
}
// This is a RasterDataCollectionQueryInput containing AreaOfInterest, Time Range
// filter and Property filters.
type RasterDataCollectionQueryWithBandFilterInput struct {
// The TimeRange Filter used in the search query.
//
// This member is required.
TimeRangeFilter *TimeRangeFilterInput
// The Area of interest to be used in the search query.
AreaOfInterest AreaOfInterest
// The list of Bands to be displayed in the result for each item.
BandFilter []string
// The Property Filters used in the search query.
PropertyFilters *PropertyFilters
noSmithyDocumentSerde
}
// The structure representing input for resampling operation.
type ResamplingConfigInput struct {
// The structure representing output resolution (in target georeferenced units) of
// the result of resampling operation.
//
// This member is required.
OutputResolution *OutputResolutionResamplingInput
// The name of the algorithm used for resampling.
AlgorithmName AlgorithmNameResampling
// Bands used in the operation. If no target bands are specified, it uses all
// bands available in the input.
TargetBands []string
noSmithyDocumentSerde
}
// The input structure for Reverse Geocoding operation type.
type ReverseGeocodingConfig struct {
// The field name for the data that describes x-axis coordinate, eg. longitude of
// a point.
//
// This member is required.
XAttributeName *string
// The field name for the data that describes y-axis coordinate, eg. latitude of a
// point.
//
// This member is required.
YAttributeName *string
noSmithyDocumentSerde
}
// The input structure for Stacking Operation.
type StackConfigInput struct {
// The structure representing output resolution (in target georeferenced units) of
// the result of stacking operation.
OutputResolution *OutputResolutionStackInput
// A list of bands to be stacked in the specified order. When the parameter is not
// provided, all the available bands in the data collection are stacked in the
// alphabetical order of their asset names.
TargetBands []string
noSmithyDocumentSerde
}
// The structure representing the configuration for Temporal Statistics operation.
type TemporalStatisticsConfigInput struct {
// The list of the statistics method options.
//
// This member is required.
Statistics []TemporalStatistics
// The input for the temporal statistics grouping by time frequency option.
GroupBy GroupBy
// The list of target band names for the temporal statistic to calculate.
TargetBands []string
noSmithyDocumentSerde
}
// The input for the time-range filter.
type TimeRangeFilterInput struct {
// The end time for the time-range filter.
//
// This member is required.
EndTime *time.Time
// The start time for the time-range filter.
//
// This member is required.
StartTime *time.Time
noSmithyDocumentSerde
}
// The output structure of the time range filter.
type TimeRangeFilterOutput struct {
// The ending time for the time range filter.
//
// This member is required.
EndTime *time.Time
// The starting time for the time range filter.
//
// This member is required.
StartTime *time.Time
noSmithyDocumentSerde
}
// The output resolution (in target georeferenced units) of the result of the
// operation
type UserDefined struct {
// The units for output resolution of the result.
//
// This member is required.
Unit Unit
// The value for output resolution of the result.
//
// This member is required.
Value *float32
noSmithyDocumentSerde
}
// It contains configs such as ReverseGeocodingConfig and MapMatchingConfig.
//
// The following types satisfy this interface:
//
// VectorEnrichmentJobConfigMemberMapMatchingConfig
// VectorEnrichmentJobConfigMemberReverseGeocodingConfig
type VectorEnrichmentJobConfig interface {
isVectorEnrichmentJobConfig()
}
// The input structure for Map Matching operation type.
type VectorEnrichmentJobConfigMemberMapMatchingConfig struct {
Value MapMatchingConfig
noSmithyDocumentSerde
}
func (*VectorEnrichmentJobConfigMemberMapMatchingConfig) isVectorEnrichmentJobConfig() {}
// The input structure for Reverse Geocoding operation type.
type VectorEnrichmentJobConfigMemberReverseGeocodingConfig struct {
Value ReverseGeocodingConfig
noSmithyDocumentSerde
}
func (*VectorEnrichmentJobConfigMemberReverseGeocodingConfig) isVectorEnrichmentJobConfig() {}
// The input structure for the data source that represents the storage type of the
// input data objects.
//
// The following types satisfy this interface:
//
// VectorEnrichmentJobDataSourceConfigInputMemberS3Data
type VectorEnrichmentJobDataSourceConfigInput interface {
isVectorEnrichmentJobDataSourceConfigInput()
}
// The input structure for the Amazon S3 data that represents the Amazon S3
// location of the input data objects.
type VectorEnrichmentJobDataSourceConfigInputMemberS3Data struct {
Value VectorEnrichmentJobS3Data
noSmithyDocumentSerde
}
func (*VectorEnrichmentJobDataSourceConfigInputMemberS3Data) isVectorEnrichmentJobDataSourceConfigInput() {
}
// VectorEnrichmentJob error details in response from GetVectorEnrichmentJob.
type VectorEnrichmentJobErrorDetails struct {
// A message that you define and then is processed and rendered by the Vector
// Enrichment job when the error occurs.
ErrorMessage *string
// The type of error generated during the Vector Enrichment job.
ErrorType VectorEnrichmentJobErrorType
noSmithyDocumentSerde
}
// VectorEnrichmentJob export error details in response from
// GetVectorEnrichmentJob.
type VectorEnrichmentJobExportErrorDetails struct {
// The message providing details about the errors generated during the Vector
// Enrichment job.
Message *string
// The output error details for an Export operation on a Vector Enrichment job.
Type VectorEnrichmentJobExportErrorType
noSmithyDocumentSerde
}
// The input structure for the InputConfig in a VectorEnrichmentJob.
type VectorEnrichmentJobInputConfig struct {
// The input structure for the data source that represents the storage type of the
// input data objects.
//
// This member is required.
DataSourceConfig VectorEnrichmentJobDataSourceConfigInput
// The input structure that defines the data source file type.
//
// This member is required.
DocumentType VectorEnrichmentJobDocumentType
noSmithyDocumentSerde
}
// The Amazon S3 data for the Vector Enrichment job.
type VectorEnrichmentJobS3Data struct {
// The URL to the Amazon S3 data for the Vector Enrichment job.
//
// This member is required.
S3Uri *string
// The Key Management Service key ID for server-side encryption.
KmsKeyId *string
noSmithyDocumentSerde
}
// The input structure for specifying ViewOffNadir property filter. ViewOffNadir
// refers to the angle from the sensor between nadir (straight down) and the scene
// center. Measured in degrees (0-90).
type ViewOffNadirInput struct {
// The minimum value for ViewOffNadir property filter. This filters items having
// ViewOffNadir greater than or equal to this value.
//
// This member is required.
LowerBound *float32
// The maximum value for ViewOffNadir property filter. This filters items having
// ViewOffNadir lesser than or equal to this value.
//
// This member is required.
UpperBound *float32
noSmithyDocumentSerde
}
// The input structure for specifying ViewSunAzimuth property filter.
// ViewSunAzimuth refers to the Sun azimuth angle. From the scene center point on
// the ground, this is the angle between truth north and the sun. Measured
// clockwise in degrees (0-360).
type ViewSunAzimuthInput struct {
// The minimum value for ViewSunAzimuth property filter. This filters items having
// ViewSunAzimuth greater than or equal to this value.
//
// This member is required.
LowerBound *float32
// The maximum value for ViewSunAzimuth property filter. This filters items having
// ViewSunAzimuth lesser than or equal to this value.
//
// This member is required.
UpperBound *float32
noSmithyDocumentSerde
}
// The input structure for specifying ViewSunElevation angle property filter.
type ViewSunElevationInput struct {
// The lower bound to view the sun elevation.
//
// This member is required.
LowerBound *float32
// The upper bound to view the sun elevation.
//
// This member is required.
UpperBound *float32
noSmithyDocumentSerde
}
// The structure representing input configuration of ZonalStatistics operation.
type ZonalStatisticsConfigInput struct {
// List of zonal statistics to compute.
//
// This member is required.
Statistics []ZonalStatistics
// The Amazon S3 path pointing to the GeoJSON containing the polygonal zones.
//
// This member is required.
ZoneS3Path *string
// Bands used in the operation. If no target bands are specified, it uses all
// bands available input.
TargetBands []string
// The Amazon Resource Name (ARN) or an ID of a Amazon Web Services Key Management
// Service (Amazon Web Services KMS) key that Amazon SageMaker uses to decrypt your
// output artifacts with Amazon S3 server-side encryption. The SageMaker execution
// role must have kms:GenerateDataKey permission. The KmsKeyId can be any of the
// following formats:
// - // KMS Key ID "1234abcd-12ab-34cd-56ef-1234567890ab"
// - // Amazon Resource Name (ARN) of a KMS Key
// "arn:aws:kms:<region>:<account>:key/<key-id-12ab-34cd-56ef-1234567890ab>"
// For more information about key identifiers, see Key identifiers (KeyID) (https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-id)
// in the Amazon Web Services Key Management Service (Amazon Web Services KMS)
// documentation.
ZoneS3PathKmsKeyId *string
noSmithyDocumentSerde
}
type noSmithyDocumentSerde = smithydocument.NoSerde
// UnknownUnionMember is returned when a union member is returned over the wire,
// but has an unknown tag.
type UnknownUnionMember struct {
Tag string
Value []byte
noSmithyDocumentSerde
}
func (*UnknownUnionMember) isAreaOfInterest() {}
func (*UnknownUnionMember) isAreaOfInterestGeometry() {}
func (*UnknownUnionMember) isJobConfigInput() {}
func (*UnknownUnionMember) isProperty() {}
func (*UnknownUnionMember) isVectorEnrichmentJobConfig() {}
func (*UnknownUnionMember) isVectorEnrichmentJobDataSourceConfigInput() {}
| 1,217 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types_test
import (
"fmt"
"github.com/aws/aws-sdk-go-v2/service/sagemakergeospatial/types"
)
func ExampleAreaOfInterest_outputUsage() {
var union types.AreaOfInterest
// type switches can be used to check the union value
switch v := union.(type) {
case *types.AreaOfInterestMemberAreaOfInterestGeometry:
_ = v.Value // Value is types.AreaOfInterestGeometry
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ types.AreaOfInterestGeometry
func ExampleAreaOfInterestGeometry_outputUsage() {
var union types.AreaOfInterestGeometry
// type switches can be used to check the union value
switch v := union.(type) {
case *types.AreaOfInterestGeometryMemberMultiPolygonGeometry:
_ = v.Value // Value is types.MultiPolygonGeometryInput
case *types.AreaOfInterestGeometryMemberPolygonGeometry:
_ = v.Value // Value is types.PolygonGeometryInput
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.PolygonGeometryInput
var _ *types.MultiPolygonGeometryInput
func ExampleJobConfigInput_outputUsage() {
var union types.JobConfigInput
// type switches can be used to check the union value
switch v := union.(type) {
case *types.JobConfigInputMemberBandMathConfig:
_ = v.Value // Value is types.BandMathConfigInput
case *types.JobConfigInputMemberCloudMaskingConfig:
_ = v.Value // Value is types.CloudMaskingConfigInput
case *types.JobConfigInputMemberCloudRemovalConfig:
_ = v.Value // Value is types.CloudRemovalConfigInput
case *types.JobConfigInputMemberGeoMosaicConfig:
_ = v.Value // Value is types.GeoMosaicConfigInput
case *types.JobConfigInputMemberLandCoverSegmentationConfig:
_ = v.Value // Value is types.LandCoverSegmentationConfigInput
case *types.JobConfigInputMemberResamplingConfig:
_ = v.Value // Value is types.ResamplingConfigInput
case *types.JobConfigInputMemberStackConfig:
_ = v.Value // Value is types.StackConfigInput
case *types.JobConfigInputMemberTemporalStatisticsConfig:
_ = v.Value // Value is types.TemporalStatisticsConfigInput
case *types.JobConfigInputMemberZonalStatisticsConfig:
_ = v.Value // Value is types.ZonalStatisticsConfigInput
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.CloudMaskingConfigInput
var _ *types.ZonalStatisticsConfigInput
var _ *types.GeoMosaicConfigInput
var _ *types.ResamplingConfigInput
var _ *types.BandMathConfigInput
var _ *types.LandCoverSegmentationConfigInput
var _ *types.TemporalStatisticsConfigInput
var _ *types.CloudRemovalConfigInput
var _ *types.StackConfigInput
func ExampleProperty_outputUsage() {
var union types.Property
// type switches can be used to check the union value
switch v := union.(type) {
case *types.PropertyMemberEoCloudCover:
_ = v.Value // Value is types.EoCloudCoverInput
case *types.PropertyMemberLandsatCloudCoverLand:
_ = v.Value // Value is types.LandsatCloudCoverLandInput
case *types.PropertyMemberPlatform:
_ = v.Value // Value is types.PlatformInput
case *types.PropertyMemberViewOffNadir:
_ = v.Value // Value is types.ViewOffNadirInput
case *types.PropertyMemberViewSunAzimuth:
_ = v.Value // Value is types.ViewSunAzimuthInput
case *types.PropertyMemberViewSunElevation:
_ = v.Value // Value is types.ViewSunElevationInput
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.LandsatCloudCoverLandInput
var _ *types.ViewSunElevationInput
var _ *types.ViewOffNadirInput
var _ *types.EoCloudCoverInput
var _ *types.PlatformInput
var _ *types.ViewSunAzimuthInput
func ExampleVectorEnrichmentJobConfig_outputUsage() {
var union types.VectorEnrichmentJobConfig
// type switches can be used to check the union value
switch v := union.(type) {
case *types.VectorEnrichmentJobConfigMemberMapMatchingConfig:
_ = v.Value // Value is types.MapMatchingConfig
case *types.VectorEnrichmentJobConfigMemberReverseGeocodingConfig:
_ = v.Value // Value is types.ReverseGeocodingConfig
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.MapMatchingConfig
var _ *types.ReverseGeocodingConfig
func ExampleVectorEnrichmentJobDataSourceConfigInput_outputUsage() {
var union types.VectorEnrichmentJobDataSourceConfigInput
// type switches can be used to check the union value
switch v := union.(type) {
case *types.VectorEnrichmentJobDataSourceConfigInputMemberS3Data:
_ = v.Value // Value is types.VectorEnrichmentJobS3Data
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.VectorEnrichmentJobS3Data
| 177 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakermetrics
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/aws/defaults"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/retry"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources"
smithy "github.com/aws/smithy-go"
smithydocument "github.com/aws/smithy-go/document"
"github.com/aws/smithy-go/logging"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net"
"net/http"
"time"
)
const ServiceID = "SageMaker Metrics"
const ServiceAPIVersion = "2022-09-30"
// Client provides the API client to make operations call for Amazon SageMaker
// Metrics Service.
type Client struct {
options Options
}
// 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 New(options Options, optFns ...func(*Options)) *Client {
options = options.Copy()
resolveDefaultLogger(&options)
setResolvedDefaultsMode(&options)
resolveRetryer(&options)
resolveHTTPClient(&options)
resolveHTTPSignerV4(&options)
resolveDefaultEndpointConfiguration(&options)
for _, fn := range optFns {
fn(&options)
}
client := &Client{
options: options,
}
return client
}
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 configuration DefaultsMode that the SDK should use when constructing the
// clients initial default settings.
DefaultsMode aws.DefaultsMode
// 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
// RetryMaxAttempts specifies the maximum number attempts an API client will call
// an operation that fails with a retryable error. A value of 0 is ignored, and
// will not be used to configure the API client created default retryer, or modify
// per operation call's retry max attempts. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. If specified in an operation call's functional
// options with a value that is different than the constructed client's Options,
// the Client's Retryer will be wrapped to use the operation's specific
// RetryMaxAttempts value.
RetryMaxAttempts int
// RetryMode specifies the retry mode the API client will be created with, if
// Retryer option is not also specified. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. Currently does not support per operation call
// overrides, may in the future.
RetryMode aws.RetryMode
// Retryer guides how HTTP requests should be retried in case of recoverable
// failures. When nil the API client will use a default retryer. The kind of
// default retry created by the API client can be changed with the RetryMode
// option.
Retryer aws.Retryer
// The RuntimeEnvironment configuration, only populated if the DefaultsMode is set
// to DefaultsModeAuto and is initialized using config.LoadDefaultConfig . You
// should not populate this structure programmatically, or rely on the values here
// within your applications.
RuntimeEnvironment aws.RuntimeEnvironment
// The initial DefaultsMode used when the client options were constructed. If the
// DefaultsMode was set to aws.DefaultsModeAuto this will store what the resolved
// value was at that point in time. Currently does not support per operation call
// overrides, may in the future.
resolvedDefaultsMode aws.DefaultsMode
// The HTTP client to invoke API calls with. Defaults to client's default HTTP
// implementation if nil.
HTTPClient HTTPClient
}
// WithAPIOptions returns a functional option for setting the Client's APIOptions
// option.
func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options) {
return func(o *Options) {
o.APIOptions = append(o.APIOptions, optFns...)
}
}
// WithEndpointResolver returns a functional option for setting the Client's
// EndpointResolver option.
func WithEndpointResolver(v EndpointResolver) func(*Options) {
return func(o *Options) {
o.EndpointResolver = v
}
}
type HTTPClient interface {
Do(*http.Request) (*http.Response, error)
}
// Copy creates a clone where the APIOptions list is deep copied.
func (o Options) Copy() Options {
to := o
to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions))
copy(to.APIOptions, o.APIOptions)
return to
}
func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) {
ctx = middleware.ClearStackValues(ctx)
stack := middleware.NewStack(opID, smithyhttp.NewStackRequest)
options := c.options.Copy()
for _, fn := range optFns {
fn(&options)
}
finalizeRetryMaxAttemptOptions(&options, *c)
finalizeClientEndpointResolverOptions(&options)
for _, fn := range stackFns {
if err := fn(stack, options); err != nil {
return nil, metadata, err
}
}
for _, fn := range options.APIOptions {
if err := fn(stack); err != nil {
return nil, metadata, err
}
}
handler := middleware.DecorateHandler(smithyhttp.NewClientHandler(options.HTTPClient), stack)
result, metadata, err = handler.Handle(ctx, params)
if err != nil {
err = &smithy.OperationError{
ServiceID: ServiceID,
OperationName: opID,
Err: err,
}
}
return result, metadata, err
}
type noSmithyDocumentSerde = smithydocument.NoSerde
func resolveDefaultLogger(o *Options) {
if o.Logger != nil {
return
}
o.Logger = logging.Nop{}
}
func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error {
return middleware.AddSetLoggerMiddleware(stack, o.Logger)
}
func setResolvedDefaultsMode(o *Options) {
if len(o.resolvedDefaultsMode) > 0 {
return
}
var mode aws.DefaultsMode
mode.SetFromString(string(o.DefaultsMode))
if mode == aws.DefaultsModeAuto {
mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment)
}
o.resolvedDefaultsMode = mode
}
// NewFromConfig returns a new client from the provided config.
func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client {
opts := Options{
Region: cfg.Region,
DefaultsMode: cfg.DefaultsMode,
RuntimeEnvironment: cfg.RuntimeEnvironment,
HTTPClient: cfg.HTTPClient,
Credentials: cfg.Credentials,
APIOptions: cfg.APIOptions,
Logger: cfg.Logger,
ClientLogMode: cfg.ClientLogMode,
}
resolveAWSRetryerProvider(cfg, &opts)
resolveAWSRetryMaxAttempts(cfg, &opts)
resolveAWSRetryMode(cfg, &opts)
resolveAWSEndpointResolver(cfg, &opts)
resolveUseDualStackEndpoint(cfg, &opts)
resolveUseFIPSEndpoint(cfg, &opts)
return New(opts, optFns...)
}
func resolveHTTPClient(o *Options) {
var buildable *awshttp.BuildableClient
if o.HTTPClient != nil {
var ok bool
buildable, ok = o.HTTPClient.(*awshttp.BuildableClient)
if !ok {
return
}
} else {
buildable = awshttp.NewBuildableClient()
}
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) {
if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok {
dialer.Timeout = dialerTimeout
}
})
buildable = buildable.WithTransportOptions(func(transport *http.Transport) {
if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok {
transport.TLSHandshakeTimeout = tlsHandshakeTimeout
}
})
}
o.HTTPClient = buildable
}
func resolveRetryer(o *Options) {
if o.Retryer != nil {
return
}
if len(o.RetryMode) == 0 {
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
o.RetryMode = modeConfig.RetryMode
}
}
if len(o.RetryMode) == 0 {
o.RetryMode = aws.RetryModeStandard
}
var standardOptions []func(*retry.StandardOptions)
if v := o.RetryMaxAttempts; v != 0 {
standardOptions = append(standardOptions, func(so *retry.StandardOptions) {
so.MaxAttempts = v
})
}
switch o.RetryMode {
case aws.RetryModeAdaptive:
var adaptiveOptions []func(*retry.AdaptiveModeOptions)
if len(standardOptions) != 0 {
adaptiveOptions = append(adaptiveOptions, func(ao *retry.AdaptiveModeOptions) {
ao.StandardOptions = append(ao.StandardOptions, standardOptions...)
})
}
o.Retryer = retry.NewAdaptiveMode(adaptiveOptions...)
default:
o.Retryer = retry.NewStandard(standardOptions...)
}
}
func resolveAWSRetryerProvider(cfg aws.Config, o *Options) {
if cfg.Retryer == nil {
return
}
o.Retryer = cfg.Retryer()
}
func resolveAWSRetryMode(cfg aws.Config, o *Options) {
if len(cfg.RetryMode) == 0 {
return
}
o.RetryMode = cfg.RetryMode
}
func resolveAWSRetryMaxAttempts(cfg aws.Config, o *Options) {
if cfg.RetryMaxAttempts == 0 {
return
}
o.RetryMaxAttempts = cfg.RetryMaxAttempts
}
func finalizeRetryMaxAttemptOptions(o *Options, client Client) {
if v := o.RetryMaxAttempts; v == 0 || v == client.options.RetryMaxAttempts {
return
}
o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts)
}
func resolveAWSEndpointResolver(cfg aws.Config, o *Options) {
if cfg.EndpointResolver == nil && cfg.EndpointResolverWithOptions == nil {
return
}
o.EndpointResolver = withEndpointResolver(cfg.EndpointResolver, cfg.EndpointResolverWithOptions, NewDefaultEndpointResolver())
}
func addClientUserAgent(stack *middleware.Stack) error {
return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "sagemakermetrics", goModuleVersion)(stack)
}
func addHTTPSignerV4Middleware(stack *middleware.Stack, o Options) error {
mw := v4.NewSignHTTPRequestMiddleware(v4.SignHTTPRequestMiddlewareOptions{
CredentialsProvider: o.Credentials,
Signer: o.HTTPSignerV4,
LogSigning: o.ClientLogMode.IsSigning(),
})
return stack.Finalize.Add(mw, middleware.After)
}
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
}
func resolveHTTPSignerV4(o *Options) {
if o.HTTPSignerV4 != nil {
return
}
o.HTTPSignerV4 = newDefaultV4Signer(*o)
}
func newDefaultV4Signer(o Options) *v4.Signer {
return v4.NewSigner(func(so *v4.SignerOptions) {
so.Logger = o.Logger
so.LogSigning = o.ClientLogMode.IsSigning()
})
}
func addRetryMiddlewares(stack *middleware.Stack, o Options) error {
mo := retry.AddRetryMiddlewaresOptions{
Retryer: o.Retryer,
LogRetryAttempts: o.ClientLogMode.IsRetries(),
}
return retry.AddRetryMiddlewares(stack, mo)
}
// resolves dual-stack endpoint configuration
func resolveUseDualStackEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseDualStackEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseDualStackEndpoint = value
}
return nil
}
// resolves FIPS endpoint configuration
func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseFIPSEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseFIPSEndpoint = value
}
return nil
}
func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error {
return awsmiddleware.AddRequestIDRetrieverMiddleware(stack)
}
func addResponseErrorMiddleware(stack *middleware.Stack) error {
return awshttp.AddResponseErrorMiddleware(stack)
}
func addRequestResponseLogging(stack *middleware.Stack, o Options) error {
return stack.Deserialize.Add(&smithyhttp.RequestResponseLogger{
LogRequest: o.ClientLogMode.IsRequest(),
LogRequestWithBody: o.ClientLogMode.IsRequestWithBody(),
LogResponse: o.ClientLogMode.IsResponse(),
LogResponseWithBody: o.ClientLogMode.IsResponseWithBody(),
}, middleware.After)
}
| 435 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakermetrics
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io/ioutil"
"net/http"
"strings"
"testing"
)
func TestClient_resolveRetryOptions(t *testing.T) {
nopClient := smithyhttp.ClientDoFunc(func(_ *http.Request) (*http.Response, error) {
return &http.Response{
StatusCode: 200,
Header: http.Header{},
Body: ioutil.NopCloser(strings.NewReader("")),
}, nil
})
cases := map[string]struct {
defaultsMode aws.DefaultsMode
retryer aws.Retryer
retryMaxAttempts int
opRetryMaxAttempts *int
retryMode aws.RetryMode
expectClientRetryMode aws.RetryMode
expectClientMaxAttempts int
expectOpMaxAttempts int
}{
"defaults": {
defaultsMode: aws.DefaultsModeStandard,
expectClientRetryMode: aws.RetryModeStandard,
expectClientMaxAttempts: 3,
expectOpMaxAttempts: 3,
},
"custom default retry": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(2),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 2,
},
"custom op no change max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(10),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op 0 max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(0),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
client := NewFromConfig(aws.Config{
DefaultsMode: c.defaultsMode,
Retryer: func() func() aws.Retryer {
if c.retryer == nil {
return nil
}
return func() aws.Retryer { return c.retryer }
}(),
HTTPClient: nopClient,
RetryMaxAttempts: c.retryMaxAttempts,
RetryMode: c.retryMode,
})
if e, a := c.expectClientRetryMode, client.options.RetryMode; e != a {
t.Errorf("expect %v retry mode, got %v", e, a)
}
if e, a := c.expectClientMaxAttempts, client.options.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v max attempts, got %v", e, a)
}
_, _, err := client.invokeOperation(context.Background(), "mockOperation", struct{}{},
[]func(*Options){
func(o *Options) {
if c.opRetryMaxAttempts == nil {
return
}
o.RetryMaxAttempts = *c.opRetryMaxAttempts
},
},
func(s *middleware.Stack, o Options) error {
s.Initialize.Clear()
s.Serialize.Clear()
s.Build.Clear()
s.Finalize.Clear()
s.Deserialize.Clear()
if e, a := c.expectOpMaxAttempts, o.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v op max attempts, got %v", e, a)
}
return nil
})
if err != nil {
t.Fatalf("expect no operation error, got %v", err)
}
})
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakermetrics
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/aws-sdk-go-v2/service/sagemakermetrics/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Used to ingest training metrics into SageMaker. These metrics can be visualized
// in SageMaker Studio and retrieved with the GetMetrics API.
func (c *Client) BatchPutMetrics(ctx context.Context, params *BatchPutMetricsInput, optFns ...func(*Options)) (*BatchPutMetricsOutput, error) {
if params == nil {
params = &BatchPutMetricsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "BatchPutMetrics", params, optFns, c.addOperationBatchPutMetricsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*BatchPutMetricsOutput)
out.ResultMetadata = metadata
return out, nil
}
type BatchPutMetricsInput struct {
// A list of raw metric values to put.
//
// This member is required.
MetricData []types.RawMetricData
// The name of the Trial Component to associate with the metrics.
//
// This member is required.
TrialComponentName *string
noSmithyDocumentSerde
}
type BatchPutMetricsOutput struct {
// Lists any errors that occur when inserting metric data.
Errors []types.BatchPutMetricsError
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationBatchPutMetricsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpBatchPutMetrics{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpBatchPutMetrics{}, 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 = addOpBatchPutMetricsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opBatchPutMetrics(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_opBatchPutMetrics(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "BatchPutMetrics",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakermetrics
import (
"bytes"
"context"
"encoding/json"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
"github.com/aws/aws-sdk-go-v2/service/sagemakermetrics/types"
smithy "github.com/aws/smithy-go"
smithyio "github.com/aws/smithy-go/io"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io"
)
type awsRestjson1_deserializeOpBatchPutMetrics struct {
}
func (*awsRestjson1_deserializeOpBatchPutMetrics) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpBatchPutMetrics) 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_deserializeOpErrorBatchPutMetrics(response, &metadata)
}
output := &BatchPutMetricsOutput{}
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_deserializeOpDocumentBatchPutMetricsOutput(&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_deserializeOpErrorBatchPutMetrics(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 {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentBatchPutMetricsOutput(v **BatchPutMetricsOutput, 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 *BatchPutMetricsOutput
if *v == nil {
sv = &BatchPutMetricsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Errors":
if err := awsRestjson1_deserializeDocumentBatchPutMetricsErrorList(&sv.Errors, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentBatchPutMetricsError(v **types.BatchPutMetricsError, 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.BatchPutMetricsError
if *v == nil {
sv = &types.BatchPutMetricsError{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Code":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PutMetricsErrorCode to be of type string, got %T instead", value)
}
sv.Code = types.PutMetricsErrorCode(jtv)
}
case "MetricIndex":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.MetricIndex = int32(i64)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentBatchPutMetricsErrorList(v *[]types.BatchPutMetricsError, 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.BatchPutMetricsError
if *v == nil {
cv = []types.BatchPutMetricsError{}
} else {
cv = *v
}
for _, value := range shape {
var col types.BatchPutMetricsError
destAddr := &col
if err := awsRestjson1_deserializeDocumentBatchPutMetricsError(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
| 249 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package sagemakermetrics provides the API client, operations, and parameter
// types for Amazon SageMaker Metrics Service.
//
// Contains all data plane API operations and data types for Amazon SageMaker
// Metrics. Use these APIs to put and retrieve (get) features related to your
// training run.
// - BatchPutMetrics (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_metrics_BatchPutMetrics.html)
package sagemakermetrics
| 11 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakermetrics
import (
"context"
"errors"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
internalendpoints "github.com/aws/aws-sdk-go-v2/service/sagemakermetrics/internal/endpoints"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net/url"
"strings"
)
// EndpointResolverOptions is the service endpoint resolver options
type EndpointResolverOptions = internalendpoints.Options
// EndpointResolver interface for resolving service endpoints.
type EndpointResolver interface {
ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
}
var _ EndpointResolver = &internalendpoints.Resolver{}
// NewDefaultEndpointResolver constructs a new service endpoint resolver
func NewDefaultEndpointResolver() *internalendpoints.Resolver {
return internalendpoints.New()
}
// 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.
type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)
func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
return fn(region, options)
}
func resolveDefaultEndpointConfiguration(o *Options) {
if o.EndpointResolver != nil {
return
}
o.EndpointResolver = NewDefaultEndpointResolver()
}
// 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.
func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver {
e := aws.Endpoint{URL: url, Source: aws.EndpointSourceCustom}
for _, fn := range optFns {
fn(&e)
}
return EndpointResolverFunc(
func(region string, options EndpointResolverOptions) (aws.Endpoint, error) {
if len(e.SigningRegion) == 0 {
e.SigningRegion = region
}
return e, nil
},
)
}
type ResolveEndpoint struct {
Resolver EndpointResolver
Options EndpointResolverOptions
}
func (*ResolveEndpoint) ID() string {
return "ResolveEndpoint"
}
func (m *ResolveEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
if m.Resolver == nil {
return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
}
eo := m.Options
eo.Logger = middleware.GetLogger(ctx)
var endpoint aws.Endpoint
endpoint, err = m.Resolver.ResolveEndpoint(awsmiddleware.GetRegion(ctx), eo)
if err != nil {
return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err)
}
req.URL, err = url.Parse(endpoint.URL)
if err != nil {
return out, metadata, fmt.Errorf("failed to parse endpoint URL: %w", err)
}
if len(awsmiddleware.GetSigningName(ctx)) == 0 {
signingName := endpoint.SigningName
if len(signingName) == 0 {
signingName = "sagemaker"
}
ctx = awsmiddleware.SetSigningName(ctx, signingName)
}
ctx = awsmiddleware.SetEndpointSource(ctx, endpoint.Source)
ctx = smithyhttp.SetHostnameImmutable(ctx, endpoint.HostnameImmutable)
ctx = awsmiddleware.SetSigningRegion(ctx, endpoint.SigningRegion)
ctx = awsmiddleware.SetPartitionID(ctx, endpoint.PartitionID)
return next.HandleSerialize(ctx, in)
}
func addResolveEndpointMiddleware(stack *middleware.Stack, o Options) error {
return stack.Serialize.Insert(&ResolveEndpoint{
Resolver: o.EndpointResolver,
Options: o.EndpointOptions,
}, "OperationSerializer", middleware.Before)
}
func removeResolveEndpointMiddleware(stack *middleware.Stack) error {
_, err := stack.Serialize.Remove((&ResolveEndpoint{}).ID())
return err
}
type wrappedEndpointResolver struct {
awsResolver aws.EndpointResolverWithOptions
resolver EndpointResolver
}
func (w *wrappedEndpointResolver) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
if w.awsResolver == nil {
goto fallback
}
endpoint, err = w.awsResolver.ResolveEndpoint(ServiceID, region, options)
if err == nil {
return endpoint, nil
}
if nf := (&aws.EndpointNotFoundError{}); !errors.As(err, &nf) {
return endpoint, err
}
fallback:
if w.resolver == nil {
return endpoint, fmt.Errorf("default endpoint resolver provided was nil")
}
return w.resolver.ResolveEndpoint(region, options)
}
type awsEndpointResolverAdaptor func(service, region string) (aws.Endpoint, error)
func (a awsEndpointResolverAdaptor) ResolveEndpoint(service, region string, options ...interface{}) (aws.Endpoint, error) {
return a(service, region)
}
var _ aws.EndpointResolverWithOptions = awsEndpointResolverAdaptor(nil)
// withEndpointResolver returns an EndpointResolver that first delegates endpoint resolution to the awsResolver.
// If awsResolver returns aws.EndpointNotFoundError error, the resolver will use the the provided
// fallbackResolver for resolution.
//
// fallbackResolver must not be nil
func withEndpointResolver(awsResolver aws.EndpointResolver, awsResolverWithOptions aws.EndpointResolverWithOptions, fallbackResolver EndpointResolver) EndpointResolver {
var resolver aws.EndpointResolverWithOptions
if awsResolverWithOptions != nil {
resolver = awsResolverWithOptions
} else if awsResolver != nil {
resolver = awsEndpointResolverAdaptor(awsResolver.ResolveEndpoint)
}
return &wrappedEndpointResolver{
awsResolver: resolver,
resolver: fallbackResolver,
}
}
func finalizeClientEndpointResolverOptions(options *Options) {
options.EndpointOptions.LogDeprecated = options.ClientLogMode.IsDeprecatedUsage()
if len(options.EndpointOptions.ResolvedRegion) == 0 {
const fipsInfix = "-fips-"
const fipsPrefix = "fips-"
const fipsSuffix = "-fips"
if strings.Contains(options.Region, fipsInfix) ||
strings.Contains(options.Region, fipsPrefix) ||
strings.Contains(options.Region, fipsSuffix) {
options.EndpointOptions.ResolvedRegion = strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(
options.Region, fipsInfix, "-"), fipsPrefix, ""), fipsSuffix, "")
options.EndpointOptions.UseFIPSEndpoint = aws.FIPSEndpointStateEnabled
}
}
}
| 201 |
aws-sdk-go-v2 | aws | Go | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT.
package sagemakermetrics
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.0.18"
| 7 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakermetrics
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakermetrics
import (
"bytes"
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/sagemakermetrics/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/encoding/httpbinding"
smithyjson "github.com/aws/smithy-go/encoding/json"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
"math"
)
type awsRestjson1_serializeOpBatchPutMetrics struct {
}
func (*awsRestjson1_serializeOpBatchPutMetrics) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpBatchPutMetrics) 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.(*BatchPutMetricsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/BatchPutMetrics")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PUT"
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_serializeOpDocumentBatchPutMetricsInput(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_serializeOpHttpBindingsBatchPutMetricsInput(v *BatchPutMetricsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentBatchPutMetricsInput(v *BatchPutMetricsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MetricData != nil {
ok := object.Key("MetricData")
if err := awsRestjson1_serializeDocumentRawMetricDataList(v.MetricData, ok); err != nil {
return err
}
}
if v.TrialComponentName != nil {
ok := object.Key("TrialComponentName")
ok.String(*v.TrialComponentName)
}
return nil
}
func awsRestjson1_serializeDocumentRawMetricData(v *types.RawMetricData, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MetricName != nil {
ok := object.Key("MetricName")
ok.String(*v.MetricName)
}
if v.Step != nil {
ok := object.Key("Step")
ok.Integer(*v.Step)
}
if v.Timestamp != nil {
ok := object.Key("Timestamp")
ok.Double(smithytime.FormatEpochSeconds(*v.Timestamp))
}
{
ok := object.Key("Value")
switch {
case math.IsNaN(v.Value):
ok.String("NaN")
case math.IsInf(v.Value, 1):
ok.String("Infinity")
case math.IsInf(v.Value, -1):
ok.String("-Infinity")
default:
ok.Double(v.Value)
}
}
return nil
}
func awsRestjson1_serializeDocumentRawMetricDataList(v []types.RawMetricData, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentRawMetricData(&v[i], av); err != nil {
return err
}
}
return nil
}
| 146 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakermetrics
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/sagemakermetrics/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpBatchPutMetrics struct {
}
func (*validateOpBatchPutMetrics) ID() string {
return "OperationInputValidation"
}
func (m *validateOpBatchPutMetrics) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*BatchPutMetricsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpBatchPutMetricsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpBatchPutMetricsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpBatchPutMetrics{}, middleware.After)
}
func validateRawMetricData(v *types.RawMetricData) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RawMetricData"}
if v.MetricName == nil {
invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
}
if v.Timestamp == nil {
invalidParams.Add(smithy.NewErrParamRequired("Timestamp"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateRawMetricDataList(v []types.RawMetricData) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RawMetricDataList"}
for i := range v {
if err := validateRawMetricData(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpBatchPutMetricsInput(v *BatchPutMetricsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchPutMetricsInput"}
if v.TrialComponentName == nil {
invalidParams.Add(smithy.NewErrParamRequired("TrialComponentName"))
}
if v.MetricData == nil {
invalidParams.Add(smithy.NewErrParamRequired("MetricData"))
} else if v.MetricData != nil {
if err := validateRawMetricDataList(v.MetricData); err != nil {
invalidParams.AddNested("MetricData", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 93 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"github.com/aws/aws-sdk-go-v2/aws"
endpoints "github.com/aws/aws-sdk-go-v2/internal/endpoints/v2"
"github.com/aws/smithy-go/logging"
"regexp"
)
// Options is the endpoint resolver configuration options
type Options struct {
// Logger is a logging implementation that log events should be sent to.
Logger logging.Logger
// LogDeprecated indicates that deprecated endpoints should be logged to the
// provided logger.
LogDeprecated bool
// ResolvedRegion is used to override the region to be resolved, rather then the
// using the value passed to the ResolveEndpoint method. This value is used by the
// SDK to translate regions like fips-us-east-1 or us-east-1-fips to an alternative
// name. You must not set this value directly in your application.
ResolvedRegion string
// DisableHTTPS informs the resolver to return an endpoint that does not use the
// HTTPS scheme.
DisableHTTPS bool
// UseDualStackEndpoint specifies the resolver must resolve a dual-stack endpoint.
UseDualStackEndpoint aws.DualStackEndpointState
// UseFIPSEndpoint specifies the resolver must resolve a FIPS endpoint.
UseFIPSEndpoint aws.FIPSEndpointState
}
func (o Options) GetResolvedRegion() string {
return o.ResolvedRegion
}
func (o Options) GetDisableHTTPS() bool {
return o.DisableHTTPS
}
func (o Options) GetUseDualStackEndpoint() aws.DualStackEndpointState {
return o.UseDualStackEndpoint
}
func (o Options) GetUseFIPSEndpoint() aws.FIPSEndpointState {
return o.UseFIPSEndpoint
}
func transformToSharedOptions(options Options) endpoints.Options {
return endpoints.Options{
Logger: options.Logger,
LogDeprecated: options.LogDeprecated,
ResolvedRegion: options.ResolvedRegion,
DisableHTTPS: options.DisableHTTPS,
UseDualStackEndpoint: options.UseDualStackEndpoint,
UseFIPSEndpoint: options.UseFIPSEndpoint,
}
}
// Resolver SageMaker Metrics endpoint resolver
type Resolver struct {
partitions endpoints.Partitions
}
// ResolveEndpoint resolves the service endpoint for the given region and options
func (r *Resolver) ResolveEndpoint(region string, options Options) (endpoint aws.Endpoint, err error) {
if len(region) == 0 {
return endpoint, &aws.MissingRegionError{}
}
opt := transformToSharedOptions(options)
return r.partitions.ResolveEndpoint(region, opt)
}
// New returns a new Resolver
func New() *Resolver {
return &Resolver{
partitions: defaultPartitions,
}
}
var partitionRegexp = struct {
Aws *regexp.Regexp
AwsCn *regexp.Regexp
AwsIso *regexp.Regexp
AwsIsoB *regexp.Regexp
AwsIsoE *regexp.Regexp
AwsIsoF *regexp.Regexp
AwsUsGov *regexp.Regexp
}{
Aws: regexp.MustCompile("^(us|eu|ap|sa|ca|me|af)\\-\\w+\\-\\d+$"),
AwsCn: regexp.MustCompile("^cn\\-\\w+\\-\\d+$"),
AwsIso: regexp.MustCompile("^us\\-iso\\-\\w+\\-\\d+$"),
AwsIsoB: regexp.MustCompile("^us\\-isob\\-\\w+\\-\\d+$"),
AwsIsoE: regexp.MustCompile("^eu\\-isoe\\-\\w+\\-\\d+$"),
AwsIsoF: regexp.MustCompile("^us\\-isof\\-\\w+\\-\\d+$"),
AwsUsGov: regexp.MustCompile("^us\\-gov\\-\\w+\\-\\d+$"),
}
var defaultPartitions = endpoints.Partitions{
{
ID: "aws",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "metrics.sagemaker.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "metrics.sagemaker-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "metrics.sagemaker-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "metrics.sagemaker.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
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-northeast-3",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-south-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-3",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-4",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ca-central-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-central-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-central-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-north-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-south-2",
}: 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: "me-central-1",
}: endpoints.Endpoint{},
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-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-west-2",
}: endpoints.Endpoint{},
},
},
{
ID: "aws-cn",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "metrics.sagemaker.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "metrics.sagemaker-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "metrics.sagemaker-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "metrics.sagemaker.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
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",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "metrics.sagemaker-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "metrics.sagemaker.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIso,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "us-iso-east-1",
}: endpoints.Endpoint{},
},
},
{
ID: "aws-iso-b",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "metrics.sagemaker-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "metrics.sagemaker.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoB,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "us-isob-east-1",
}: endpoints.Endpoint{},
},
},
{
ID: "aws-iso-e",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "metrics.sagemaker-fips.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "metrics.sagemaker.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoE,
IsRegionalized: true,
},
{
ID: "aws-iso-f",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "metrics.sagemaker-fips.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "metrics.sagemaker.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoF,
IsRegionalized: true,
},
{
ID: "aws-us-gov",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "metrics.sagemaker.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "metrics.sagemaker-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "metrics.sagemaker-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "metrics.sagemaker.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "us-gov-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-gov-west-1",
}: endpoints.Endpoint{},
},
},
}
| 406 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"testing"
)
func TestRegexCompile(t *testing.T) {
_ = defaultPartitions
}
| 12 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
type PutMetricsErrorCode string
// Enum values for PutMetricsErrorCode
const (
PutMetricsErrorCodeMetricLimitExceeded PutMetricsErrorCode = "METRIC_LIMIT_EXCEEDED"
PutMetricsErrorCodeInternalError PutMetricsErrorCode = "INTERNAL_ERROR"
PutMetricsErrorCodeValidationError PutMetricsErrorCode = "VALIDATION_ERROR"
PutMetricsErrorCodeConflictError PutMetricsErrorCode = "CONFLICT_ERROR"
)
// Values returns all known values for PutMetricsErrorCode. 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 (PutMetricsErrorCode) Values() []PutMetricsErrorCode {
return []PutMetricsErrorCode{
"METRIC_LIMIT_EXCEEDED",
"INTERNAL_ERROR",
"VALIDATION_ERROR",
"CONFLICT_ERROR",
}
}
| 26 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
smithydocument "github.com/aws/smithy-go/document"
"time"
)
// An error that occured when putting the metric data.
type BatchPutMetricsError struct {
// The error code of an error that occured when attempting to put metrics.
// - METRIC_LIMIT_EXCEEDED : The maximum amount of metrics per resource is
// exceeded.
// - INTERNAL_ERROR : An internal error occured.
// - VALIDATION_ERROR : The metric data failed validation.
// - CONFLICT_ERROR : Multiple requests attempted to modify the same data
// simultaneously.
Code PutMetricsErrorCode
// An index that corresponds to the metric in the request.
MetricIndex int32
noSmithyDocumentSerde
}
// The raw metric data to associate with the resource.
type RawMetricData struct {
// The name of the metric.
//
// This member is required.
MetricName *string
// The time that the metric was recorded.
//
// This member is required.
Timestamp *time.Time
// The metric value.
//
// This member is required.
Value float64
// The metric step (epoch).
Step *int32
noSmithyDocumentSerde
}
type noSmithyDocumentSerde = smithydocument.NoSerde
| 53 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerruntime
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/aws/defaults"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/retry"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources"
smithy "github.com/aws/smithy-go"
smithydocument "github.com/aws/smithy-go/document"
"github.com/aws/smithy-go/logging"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net"
"net/http"
"time"
)
const ServiceID = "SageMaker Runtime"
const ServiceAPIVersion = "2017-05-13"
// Client provides the API client to make operations call for Amazon SageMaker
// Runtime.
type Client struct {
options Options
}
// 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 New(options Options, optFns ...func(*Options)) *Client {
options = options.Copy()
resolveDefaultLogger(&options)
setResolvedDefaultsMode(&options)
resolveRetryer(&options)
resolveHTTPClient(&options)
resolveHTTPSignerV4(&options)
resolveDefaultEndpointConfiguration(&options)
for _, fn := range optFns {
fn(&options)
}
client := &Client{
options: options,
}
return client
}
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 configuration DefaultsMode that the SDK should use when constructing the
// clients initial default settings.
DefaultsMode aws.DefaultsMode
// 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
// RetryMaxAttempts specifies the maximum number attempts an API client will call
// an operation that fails with a retryable error. A value of 0 is ignored, and
// will not be used to configure the API client created default retryer, or modify
// per operation call's retry max attempts. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. If specified in an operation call's functional
// options with a value that is different than the constructed client's Options,
// the Client's Retryer will be wrapped to use the operation's specific
// RetryMaxAttempts value.
RetryMaxAttempts int
// RetryMode specifies the retry mode the API client will be created with, if
// Retryer option is not also specified. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. Currently does not support per operation call
// overrides, may in the future.
RetryMode aws.RetryMode
// Retryer guides how HTTP requests should be retried in case of recoverable
// failures. When nil the API client will use a default retryer. The kind of
// default retry created by the API client can be changed with the RetryMode
// option.
Retryer aws.Retryer
// The RuntimeEnvironment configuration, only populated if the DefaultsMode is set
// to DefaultsModeAuto and is initialized using config.LoadDefaultConfig . You
// should not populate this structure programmatically, or rely on the values here
// within your applications.
RuntimeEnvironment aws.RuntimeEnvironment
// The initial DefaultsMode used when the client options were constructed. If the
// DefaultsMode was set to aws.DefaultsModeAuto this will store what the resolved
// value was at that point in time. Currently does not support per operation call
// overrides, may in the future.
resolvedDefaultsMode aws.DefaultsMode
// The HTTP client to invoke API calls with. Defaults to client's default HTTP
// implementation if nil.
HTTPClient HTTPClient
}
// WithAPIOptions returns a functional option for setting the Client's APIOptions
// option.
func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options) {
return func(o *Options) {
o.APIOptions = append(o.APIOptions, optFns...)
}
}
// WithEndpointResolver returns a functional option for setting the Client's
// EndpointResolver option.
func WithEndpointResolver(v EndpointResolver) func(*Options) {
return func(o *Options) {
o.EndpointResolver = v
}
}
type HTTPClient interface {
Do(*http.Request) (*http.Response, error)
}
// Copy creates a clone where the APIOptions list is deep copied.
func (o Options) Copy() Options {
to := o
to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions))
copy(to.APIOptions, o.APIOptions)
return to
}
func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) {
ctx = middleware.ClearStackValues(ctx)
stack := middleware.NewStack(opID, smithyhttp.NewStackRequest)
options := c.options.Copy()
for _, fn := range optFns {
fn(&options)
}
finalizeRetryMaxAttemptOptions(&options, *c)
finalizeClientEndpointResolverOptions(&options)
for _, fn := range stackFns {
if err := fn(stack, options); err != nil {
return nil, metadata, err
}
}
for _, fn := range options.APIOptions {
if err := fn(stack); err != nil {
return nil, metadata, err
}
}
handler := middleware.DecorateHandler(smithyhttp.NewClientHandler(options.HTTPClient), stack)
result, metadata, err = handler.Handle(ctx, params)
if err != nil {
err = &smithy.OperationError{
ServiceID: ServiceID,
OperationName: opID,
Err: err,
}
}
return result, metadata, err
}
type noSmithyDocumentSerde = smithydocument.NoSerde
func resolveDefaultLogger(o *Options) {
if o.Logger != nil {
return
}
o.Logger = logging.Nop{}
}
func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error {
return middleware.AddSetLoggerMiddleware(stack, o.Logger)
}
func setResolvedDefaultsMode(o *Options) {
if len(o.resolvedDefaultsMode) > 0 {
return
}
var mode aws.DefaultsMode
mode.SetFromString(string(o.DefaultsMode))
if mode == aws.DefaultsModeAuto {
mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment)
}
o.resolvedDefaultsMode = mode
}
// NewFromConfig returns a new client from the provided config.
func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client {
opts := Options{
Region: cfg.Region,
DefaultsMode: cfg.DefaultsMode,
RuntimeEnvironment: cfg.RuntimeEnvironment,
HTTPClient: cfg.HTTPClient,
Credentials: cfg.Credentials,
APIOptions: cfg.APIOptions,
Logger: cfg.Logger,
ClientLogMode: cfg.ClientLogMode,
}
resolveAWSRetryerProvider(cfg, &opts)
resolveAWSRetryMaxAttempts(cfg, &opts)
resolveAWSRetryMode(cfg, &opts)
resolveAWSEndpointResolver(cfg, &opts)
resolveUseDualStackEndpoint(cfg, &opts)
resolveUseFIPSEndpoint(cfg, &opts)
return New(opts, optFns...)
}
func resolveHTTPClient(o *Options) {
var buildable *awshttp.BuildableClient
if o.HTTPClient != nil {
var ok bool
buildable, ok = o.HTTPClient.(*awshttp.BuildableClient)
if !ok {
return
}
} else {
buildable = awshttp.NewBuildableClient()
}
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) {
if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok {
dialer.Timeout = dialerTimeout
}
})
buildable = buildable.WithTransportOptions(func(transport *http.Transport) {
if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok {
transport.TLSHandshakeTimeout = tlsHandshakeTimeout
}
})
}
o.HTTPClient = buildable
}
func resolveRetryer(o *Options) {
if o.Retryer != nil {
return
}
if len(o.RetryMode) == 0 {
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
o.RetryMode = modeConfig.RetryMode
}
}
if len(o.RetryMode) == 0 {
o.RetryMode = aws.RetryModeStandard
}
var standardOptions []func(*retry.StandardOptions)
if v := o.RetryMaxAttempts; v != 0 {
standardOptions = append(standardOptions, func(so *retry.StandardOptions) {
so.MaxAttempts = v
})
}
switch o.RetryMode {
case aws.RetryModeAdaptive:
var adaptiveOptions []func(*retry.AdaptiveModeOptions)
if len(standardOptions) != 0 {
adaptiveOptions = append(adaptiveOptions, func(ao *retry.AdaptiveModeOptions) {
ao.StandardOptions = append(ao.StandardOptions, standardOptions...)
})
}
o.Retryer = retry.NewAdaptiveMode(adaptiveOptions...)
default:
o.Retryer = retry.NewStandard(standardOptions...)
}
}
func resolveAWSRetryerProvider(cfg aws.Config, o *Options) {
if cfg.Retryer == nil {
return
}
o.Retryer = cfg.Retryer()
}
func resolveAWSRetryMode(cfg aws.Config, o *Options) {
if len(cfg.RetryMode) == 0 {
return
}
o.RetryMode = cfg.RetryMode
}
func resolveAWSRetryMaxAttempts(cfg aws.Config, o *Options) {
if cfg.RetryMaxAttempts == 0 {
return
}
o.RetryMaxAttempts = cfg.RetryMaxAttempts
}
func finalizeRetryMaxAttemptOptions(o *Options, client Client) {
if v := o.RetryMaxAttempts; v == 0 || v == client.options.RetryMaxAttempts {
return
}
o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts)
}
func resolveAWSEndpointResolver(cfg aws.Config, o *Options) {
if cfg.EndpointResolver == nil && cfg.EndpointResolverWithOptions == nil {
return
}
o.EndpointResolver = withEndpointResolver(cfg.EndpointResolver, cfg.EndpointResolverWithOptions, NewDefaultEndpointResolver())
}
func addClientUserAgent(stack *middleware.Stack) error {
return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "sagemakerruntime", goModuleVersion)(stack)
}
func addHTTPSignerV4Middleware(stack *middleware.Stack, o Options) error {
mw := v4.NewSignHTTPRequestMiddleware(v4.SignHTTPRequestMiddlewareOptions{
CredentialsProvider: o.Credentials,
Signer: o.HTTPSignerV4,
LogSigning: o.ClientLogMode.IsSigning(),
})
return stack.Finalize.Add(mw, middleware.After)
}
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
}
func resolveHTTPSignerV4(o *Options) {
if o.HTTPSignerV4 != nil {
return
}
o.HTTPSignerV4 = newDefaultV4Signer(*o)
}
func newDefaultV4Signer(o Options) *v4.Signer {
return v4.NewSigner(func(so *v4.SignerOptions) {
so.Logger = o.Logger
so.LogSigning = o.ClientLogMode.IsSigning()
})
}
func addRetryMiddlewares(stack *middleware.Stack, o Options) error {
mo := retry.AddRetryMiddlewaresOptions{
Retryer: o.Retryer,
LogRetryAttempts: o.ClientLogMode.IsRetries(),
}
return retry.AddRetryMiddlewares(stack, mo)
}
// resolves dual-stack endpoint configuration
func resolveUseDualStackEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseDualStackEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseDualStackEndpoint = value
}
return nil
}
// resolves FIPS endpoint configuration
func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseFIPSEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseFIPSEndpoint = value
}
return nil
}
func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error {
return awsmiddleware.AddRequestIDRetrieverMiddleware(stack)
}
func addResponseErrorMiddleware(stack *middleware.Stack) error {
return awshttp.AddResponseErrorMiddleware(stack)
}
func addRequestResponseLogging(stack *middleware.Stack, o Options) error {
return stack.Deserialize.Add(&smithyhttp.RequestResponseLogger{
LogRequest: o.ClientLogMode.IsRequest(),
LogRequestWithBody: o.ClientLogMode.IsRequestWithBody(),
LogResponse: o.ClientLogMode.IsResponse(),
LogResponseWithBody: o.ClientLogMode.IsResponseWithBody(),
}, middleware.After)
}
| 435 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerruntime
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io/ioutil"
"net/http"
"strings"
"testing"
)
func TestClient_resolveRetryOptions(t *testing.T) {
nopClient := smithyhttp.ClientDoFunc(func(_ *http.Request) (*http.Response, error) {
return &http.Response{
StatusCode: 200,
Header: http.Header{},
Body: ioutil.NopCloser(strings.NewReader("")),
}, nil
})
cases := map[string]struct {
defaultsMode aws.DefaultsMode
retryer aws.Retryer
retryMaxAttempts int
opRetryMaxAttempts *int
retryMode aws.RetryMode
expectClientRetryMode aws.RetryMode
expectClientMaxAttempts int
expectOpMaxAttempts int
}{
"defaults": {
defaultsMode: aws.DefaultsModeStandard,
expectClientRetryMode: aws.RetryModeStandard,
expectClientMaxAttempts: 3,
expectOpMaxAttempts: 3,
},
"custom default retry": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(2),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 2,
},
"custom op no change max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(10),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op 0 max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(0),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
client := NewFromConfig(aws.Config{
DefaultsMode: c.defaultsMode,
Retryer: func() func() aws.Retryer {
if c.retryer == nil {
return nil
}
return func() aws.Retryer { return c.retryer }
}(),
HTTPClient: nopClient,
RetryMaxAttempts: c.retryMaxAttempts,
RetryMode: c.retryMode,
})
if e, a := c.expectClientRetryMode, client.options.RetryMode; e != a {
t.Errorf("expect %v retry mode, got %v", e, a)
}
if e, a := c.expectClientMaxAttempts, client.options.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v max attempts, got %v", e, a)
}
_, _, err := client.invokeOperation(context.Background(), "mockOperation", struct{}{},
[]func(*Options){
func(o *Options) {
if c.opRetryMaxAttempts == nil {
return
}
o.RetryMaxAttempts = *c.opRetryMaxAttempts
},
},
func(s *middleware.Stack, o Options) error {
s.Initialize.Clear()
s.Serialize.Clear()
s.Build.Clear()
s.Finalize.Clear()
s.Deserialize.Clear()
if e, a := c.expectOpMaxAttempts, o.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v op max attempts, got %v", e, a)
}
return nil
})
if err != nil {
t.Fatalf("expect no operation error, got %v", err)
}
})
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerruntime
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"
)
// After you deploy a model into production using Amazon SageMaker hosting
// services, your client applications use this API to get inferences from the model
// hosted at the specified endpoint. For an overview of Amazon SageMaker, see How
// It Works (https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works.html) .
// Amazon SageMaker strips all POST headers except those supported by the API.
// Amazon SageMaker might add additional headers. You should not rely on the
// behavior of headers outside those enumerated in the request syntax. Calls to
// InvokeEndpoint are authenticated by using Amazon Web Services Signature Version
// 4. For information, see Authenticating Requests (Amazon Web Services Signature
// Version 4) (https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html)
// in the Amazon S3 API Reference. A customer's model containers must respond to
// requests within 60 seconds. The model itself can have a maximum processing time
// of 60 seconds before responding to invocations. If your model is going to take
// 50-60 seconds of processing time, the SDK socket timeout should be set to be 70
// seconds. Endpoints are scoped to an individual account, and are not public. The
// URL does not contain the account ID, but Amazon SageMaker determines the account
// ID from the authentication token that is supplied by the caller.
func (c *Client) InvokeEndpoint(ctx context.Context, params *InvokeEndpointInput, optFns ...func(*Options)) (*InvokeEndpointOutput, error) {
if params == nil {
params = &InvokeEndpointInput{}
}
result, metadata, err := c.invokeOperation(ctx, "InvokeEndpoint", params, optFns, c.addOperationInvokeEndpointMiddlewares)
if err != nil {
return nil, err
}
out := result.(*InvokeEndpointOutput)
out.ResultMetadata = metadata
return out, nil
}
type InvokeEndpointInput struct {
// Provides input data, in the format specified in the ContentType request header.
// Amazon SageMaker passes all of the data in the body to the model. For
// information about the format of the request body, see Common Data
// Formats-Inference (https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html)
// .
//
// This member is required.
Body []byte
// The name of the endpoint that you specified when you created the endpoint using
// the CreateEndpoint (https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateEndpoint.html)
// API.
//
// This member is required.
EndpointName *string
// The desired MIME type of the inference in the response.
Accept *string
// The MIME type of the input data in the request body.
ContentType *string
// Provides additional information about a request for an inference submitted to a
// model hosted at an Amazon SageMaker endpoint. The information is an opaque value
// that is forwarded verbatim. You could use this value, for example, to provide an
// ID that you can use to track a request or to provide other metadata that a
// service endpoint was programmed to process. The value must consist of no more
// than 1024 visible US-ASCII characters as specified in Section 3.3.6. Field
// Value Components (https://tools.ietf.org/html/rfc7230#section-3.2.6) of the
// Hypertext Transfer Protocol (HTTP/1.1). The code in your model is responsible
// for setting or updating any custom attributes in the response. If your code does
// not set this value in the response, an empty value is returned. For example, if
// a custom attribute represents the trace ID, your model can prepend the custom
// attribute with Trace ID: in your post-processing function. This feature is
// currently supported in the Amazon Web Services SDKs but not in the Amazon
// SageMaker Python SDK.
CustomAttributes *string
// An optional JMESPath expression used to override the EnableExplanations
// parameter of the ClarifyExplainerConfig API. See the EnableExplanations (https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-online-explainability-create-endpoint.html#clarify-online-explainability-create-endpoint-enable)
// section in the developer guide for more information.
EnableExplanations *string
// If you provide a value, it is added to the captured data when you enable data
// capture on the endpoint. For information about data capture, see Capture Data (https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-data-capture.html)
// .
InferenceId *string
// If the endpoint hosts multiple containers and is configured to use direct
// invocation, this parameter specifies the host name of the container to invoke.
TargetContainerHostname *string
// The model to request for inference when invoking a multi-model endpoint.
TargetModel *string
// Specify the production variant to send the inference request to when invoking
// an endpoint that is running two or more variants. Note that this parameter
// overrides the default behavior for the endpoint, which is to distribute the
// invocation traffic based on the variant weights. For information about how to
// use variant targeting to perform a/b testing, see Test models in production (https://docs.aws.amazon.com/sagemaker/latest/dg/model-ab-testing.html)
TargetVariant *string
noSmithyDocumentSerde
}
type InvokeEndpointOutput struct {
// Includes the inference provided by the model. For information about the format
// of the response body, see Common Data Formats-Inference (https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html)
// . If the explainer is activated, the body includes the explanations provided by
// the model. For more information, see the Response section under Invoke the
// Endpoint (https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-online-explainability-invoke-endpoint.html#clarify-online-explainability-response)
// in the Developer Guide.
//
// This member is required.
Body []byte
// The MIME type of the inference returned in the response body.
ContentType *string
// Provides additional information in the response about the inference returned by
// a model hosted at an Amazon SageMaker endpoint. The information is an opaque
// value that is forwarded verbatim. You could use this value, for example, to
// return an ID received in the CustomAttributes header of a request or other
// metadata that a service endpoint was programmed to produce. The value must
// consist of no more than 1024 visible US-ASCII characters as specified in
// Section 3.3.6. Field Value Components (https://tools.ietf.org/html/rfc7230#section-3.2.6)
// of the Hypertext Transfer Protocol (HTTP/1.1). If the customer wants the custom
// attribute returned, the model must set the custom attribute to be included on
// the way back. The code in your model is responsible for setting or updating any
// custom attributes in the response. If your code does not set this value in the
// response, an empty value is returned. For example, if a custom attribute
// represents the trace ID, your model can prepend the custom attribute with Trace
// ID: in your post-processing function. This feature is currently supported in the
// Amazon Web Services SDKs but not in the Amazon SageMaker Python SDK.
CustomAttributes *string
// Identifies the production variant that was invoked.
InvokedProductionVariant *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationInvokeEndpointMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpInvokeEndpoint{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpInvokeEndpoint{}, 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 = addOpInvokeEndpointValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opInvokeEndpoint(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_opInvokeEndpoint(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "InvokeEndpoint",
}
}
| 227 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerruntime
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"
)
// After you deploy a model into production using Amazon SageMaker hosting
// services, your client applications use this API to get inferences from the model
// hosted at the specified endpoint in an asynchronous manner. Inference requests
// sent to this API are enqueued for asynchronous processing. The processing of the
// inference request may or may not complete before you receive a response from
// this API. The response from this API will not contain the result of the
// inference request but contain information about where you can locate it. Amazon
// SageMaker strips all POST headers except those supported by the API. Amazon
// SageMaker might add additional headers. You should not rely on the behavior of
// headers outside those enumerated in the request syntax. Calls to
// InvokeEndpointAsync are authenticated by using Amazon Web Services Signature
// Version 4. For information, see Authenticating Requests (Amazon Web Services
// Signature Version 4) (https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html)
// in the Amazon S3 API Reference.
func (c *Client) InvokeEndpointAsync(ctx context.Context, params *InvokeEndpointAsyncInput, optFns ...func(*Options)) (*InvokeEndpointAsyncOutput, error) {
if params == nil {
params = &InvokeEndpointAsyncInput{}
}
result, metadata, err := c.invokeOperation(ctx, "InvokeEndpointAsync", params, optFns, c.addOperationInvokeEndpointAsyncMiddlewares)
if err != nil {
return nil, err
}
out := result.(*InvokeEndpointAsyncOutput)
out.ResultMetadata = metadata
return out, nil
}
type InvokeEndpointAsyncInput struct {
// The name of the endpoint that you specified when you created the endpoint using
// the CreateEndpoint (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)
// API.
//
// This member is required.
EndpointName *string
// The Amazon S3 URI where the inference request payload is stored.
//
// This member is required.
InputLocation *string
// The desired MIME type of the inference in the response.
Accept *string
// The MIME type of the input data in the request body.
ContentType *string
// Provides additional information about a request for an inference submitted to a
// model hosted at an Amazon SageMaker endpoint. The information is an opaque value
// that is forwarded verbatim. You could use this value, for example, to provide an
// ID that you can use to track a request or to provide other metadata that a
// service endpoint was programmed to process. The value must consist of no more
// than 1024 visible US-ASCII characters as specified in Section 3.3.6. Field
// Value Components (https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.6)
// of the Hypertext Transfer Protocol (HTTP/1.1). The code in your model is
// responsible for setting or updating any custom attributes in the response. If
// your code does not set this value in the response, an empty value is returned.
// For example, if a custom attribute represents the trace ID, your model can
// prepend the custom attribute with Trace ID : in your post-processing function.
// This feature is currently supported in the Amazon Web Services SDKs but not in
// the Amazon SageMaker Python SDK.
CustomAttributes *string
// The identifier for the inference request. Amazon SageMaker will generate an
// identifier for you if none is specified.
InferenceId *string
// Maximum amount of time in seconds a request can be processed before it is
// marked as expired. The default is 15 minutes, or 900 seconds.
InvocationTimeoutSeconds *int32
// Maximum age in seconds a request can be in the queue before it is marked as
// expired. The default is 6 hours, or 21,600 seconds.
RequestTTLSeconds *int32
noSmithyDocumentSerde
}
type InvokeEndpointAsyncOutput struct {
// The Amazon S3 URI where the inference failure response payload is stored.
FailureLocation *string
// Identifier for an inference request. This will be the same as the InferenceId
// specified in the input. Amazon SageMaker will generate an identifier for you if
// you do not specify one.
InferenceId *string
// The Amazon S3 URI where the inference response payload is stored.
OutputLocation *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationInvokeEndpointAsyncMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpInvokeEndpointAsync{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpInvokeEndpointAsync{}, 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 = addOpInvokeEndpointAsyncValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opInvokeEndpointAsync(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_opInvokeEndpointAsync(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "InvokeEndpointAsync",
}
}
| 186 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerruntime
import (
"bytes"
"context"
"encoding/json"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
"github.com/aws/aws-sdk-go-v2/service/sagemakerruntime/types"
smithy "github.com/aws/smithy-go"
smithyio "github.com/aws/smithy-go/io"
"github.com/aws/smithy-go/middleware"
"github.com/aws/smithy-go/ptr"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io"
"strings"
)
type awsRestjson1_deserializeOpInvokeEndpoint struct {
}
func (*awsRestjson1_deserializeOpInvokeEndpoint) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpInvokeEndpoint) 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_deserializeOpErrorInvokeEndpoint(response, &metadata)
}
output := &InvokeEndpointOutput{}
out.Result = output
err = awsRestjson1_deserializeOpHttpBindingsInvokeEndpointOutput(output, response)
if err != nil {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
}
err = awsRestjson1_deserializeOpDocumentInvokeEndpointOutput(output, response.Body, response.ContentLength)
if err != nil {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to deserialize response payload, %w", err)}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorInvokeEndpoint(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("InternalDependencyException", errorCode):
return awsRestjson1_deserializeErrorInternalDependencyException(response, errorBody)
case strings.EqualFold("InternalFailure", errorCode):
return awsRestjson1_deserializeErrorInternalFailure(response, errorBody)
case strings.EqualFold("ModelError", errorCode):
return awsRestjson1_deserializeErrorModelError(response, errorBody)
case strings.EqualFold("ModelNotReadyException", errorCode):
return awsRestjson1_deserializeErrorModelNotReadyException(response, errorBody)
case strings.EqualFold("ServiceUnavailable", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailable(response, errorBody)
case strings.EqualFold("ValidationError", errorCode):
return awsRestjson1_deserializeErrorValidationError(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpHttpBindingsInvokeEndpointOutput(v *InvokeEndpointOutput, response *smithyhttp.Response) error {
if v == nil {
return fmt.Errorf("unsupported deserialization for nil %T", v)
}
if headerValues := response.Header.Values("Content-Type"); len(headerValues) != 0 {
headerValues[0] = strings.TrimSpace(headerValues[0])
v.ContentType = ptr.String(headerValues[0])
}
if headerValues := response.Header.Values("X-Amzn-SageMaker-Custom-Attributes"); len(headerValues) != 0 {
headerValues[0] = strings.TrimSpace(headerValues[0])
v.CustomAttributes = ptr.String(headerValues[0])
}
if headerValues := response.Header.Values("x-Amzn-Invoked-Production-Variant"); len(headerValues) != 0 {
headerValues[0] = strings.TrimSpace(headerValues[0])
v.InvokedProductionVariant = ptr.String(headerValues[0])
}
return nil
}
func awsRestjson1_deserializeOpDocumentInvokeEndpointOutput(v *InvokeEndpointOutput, body io.ReadCloser, contentLength int64) error {
if v == nil {
return fmt.Errorf("unsupported deserialization of nil %T", v)
}
var buf bytes.Buffer
if contentLength > 0 {
buf.Grow(int(contentLength))
} else {
buf.Grow(512)
}
_, err := buf.ReadFrom(body)
if err != nil {
return err
}
if buf.Len() > 0 {
v.Body = buf.Bytes()
}
return nil
}
type awsRestjson1_deserializeOpInvokeEndpointAsync struct {
}
func (*awsRestjson1_deserializeOpInvokeEndpointAsync) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpInvokeEndpointAsync) 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_deserializeOpErrorInvokeEndpointAsync(response, &metadata)
}
output := &InvokeEndpointAsyncOutput{}
out.Result = output
err = awsRestjson1_deserializeOpHttpBindingsInvokeEndpointAsyncOutput(output, response)
if err != nil {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response with invalid Http bindings, %w", err)}
}
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_deserializeOpDocumentInvokeEndpointAsyncOutput(&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_deserializeOpErrorInvokeEndpointAsync(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("InternalFailure", errorCode):
return awsRestjson1_deserializeErrorInternalFailure(response, errorBody)
case strings.EqualFold("ServiceUnavailable", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailable(response, errorBody)
case strings.EqualFold("ValidationError", errorCode):
return awsRestjson1_deserializeErrorValidationError(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpHttpBindingsInvokeEndpointAsyncOutput(v *InvokeEndpointAsyncOutput, response *smithyhttp.Response) error {
if v == nil {
return fmt.Errorf("unsupported deserialization for nil %T", v)
}
if headerValues := response.Header.Values("X-Amzn-SageMaker-FailureLocation"); len(headerValues) != 0 {
headerValues[0] = strings.TrimSpace(headerValues[0])
v.FailureLocation = ptr.String(headerValues[0])
}
if headerValues := response.Header.Values("X-Amzn-SageMaker-OutputLocation"); len(headerValues) != 0 {
headerValues[0] = strings.TrimSpace(headerValues[0])
v.OutputLocation = ptr.String(headerValues[0])
}
return nil
}
func awsRestjson1_deserializeOpDocumentInvokeEndpointAsyncOutput(v **InvokeEndpointAsyncOutput, 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 *InvokeEndpointAsyncOutput
if *v == nil {
sv = &InvokeEndpointAsyncOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "InferenceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Header to be of type string, got %T instead", value)
}
sv.InferenceId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeErrorInternalDependencyException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.InternalDependencyException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, 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 err
}
err := awsRestjson1_deserializeDocumentInternalDependencyException(&output, shape)
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)
return output
}
func awsRestjson1_deserializeErrorInternalFailure(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.InternalFailure{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, 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 err
}
err := awsRestjson1_deserializeDocumentInternalFailure(&output, shape)
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)
return output
}
func awsRestjson1_deserializeErrorModelError(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ModelError{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, 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 err
}
err := awsRestjson1_deserializeDocumentModelError(&output, shape)
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)
return output
}
func awsRestjson1_deserializeErrorModelNotReadyException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ModelNotReadyException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, 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 err
}
err := awsRestjson1_deserializeDocumentModelNotReadyException(&output, shape)
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)
return output
}
func awsRestjson1_deserializeErrorServiceUnavailable(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ServiceUnavailable{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, 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 err
}
err := awsRestjson1_deserializeDocumentServiceUnavailable(&output, shape)
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)
return output
}
func awsRestjson1_deserializeErrorValidationError(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ValidationError{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, 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 err
}
err := awsRestjson1_deserializeDocumentValidationError(&output, shape)
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)
return output
}
func awsRestjson1_deserializeDocumentInternalDependencyException(v **types.InternalDependencyException, 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.InternalDependencyException
if *v == nil {
sv = &types.InternalDependencyException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Message to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentInternalFailure(v **types.InternalFailure, 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.InternalFailure
if *v == nil {
sv = &types.InternalFailure{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Message to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentModelError(v **types.ModelError, 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.ModelError
if *v == nil {
sv = &types.ModelError{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "LogStreamArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LogStreamArn to be of type string, got %T instead", value)
}
sv.LogStreamArn = ptr.String(jtv)
}
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Message to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
case "OriginalMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Message to be of type string, got %T instead", value)
}
sv.OriginalMessage = ptr.String(jtv)
}
case "OriginalStatusCode":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected StatusCode to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.OriginalStatusCode = ptr.Int32(int32(i64))
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentModelNotReadyException(v **types.ModelNotReadyException, 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.ModelNotReadyException
if *v == nil {
sv = &types.ModelNotReadyException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Message to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentServiceUnavailable(v **types.ServiceUnavailable, 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.ServiceUnavailable
if *v == nil {
sv = &types.ServiceUnavailable{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Message to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentValidationError(v **types.ValidationError, 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.ValidationError
if *v == nil {
sv = &types.ValidationError{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Message to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
| 838 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package sagemakerruntime provides the API client, operations, and parameter
// types for Amazon SageMaker Runtime.
//
// The Amazon SageMaker runtime API.
package sagemakerruntime
| 8 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerruntime
import (
"context"
"errors"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
internalendpoints "github.com/aws/aws-sdk-go-v2/service/sagemakerruntime/internal/endpoints"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net/url"
"strings"
)
// EndpointResolverOptions is the service endpoint resolver options
type EndpointResolverOptions = internalendpoints.Options
// EndpointResolver interface for resolving service endpoints.
type EndpointResolver interface {
ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
}
var _ EndpointResolver = &internalendpoints.Resolver{}
// NewDefaultEndpointResolver constructs a new service endpoint resolver
func NewDefaultEndpointResolver() *internalendpoints.Resolver {
return internalendpoints.New()
}
// 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.
type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)
func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
return fn(region, options)
}
func resolveDefaultEndpointConfiguration(o *Options) {
if o.EndpointResolver != nil {
return
}
o.EndpointResolver = NewDefaultEndpointResolver()
}
// 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.
func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver {
e := aws.Endpoint{URL: url, Source: aws.EndpointSourceCustom}
for _, fn := range optFns {
fn(&e)
}
return EndpointResolverFunc(
func(region string, options EndpointResolverOptions) (aws.Endpoint, error) {
if len(e.SigningRegion) == 0 {
e.SigningRegion = region
}
return e, nil
},
)
}
type ResolveEndpoint struct {
Resolver EndpointResolver
Options EndpointResolverOptions
}
func (*ResolveEndpoint) ID() string {
return "ResolveEndpoint"
}
func (m *ResolveEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
}
if m.Resolver == nil {
return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
}
eo := m.Options
eo.Logger = middleware.GetLogger(ctx)
var endpoint aws.Endpoint
endpoint, err = m.Resolver.ResolveEndpoint(awsmiddleware.GetRegion(ctx), eo)
if err != nil {
return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err)
}
req.URL, err = url.Parse(endpoint.URL)
if err != nil {
return out, metadata, fmt.Errorf("failed to parse endpoint URL: %w", err)
}
if len(awsmiddleware.GetSigningName(ctx)) == 0 {
signingName := endpoint.SigningName
if len(signingName) == 0 {
signingName = "sagemaker"
}
ctx = awsmiddleware.SetSigningName(ctx, signingName)
}
ctx = awsmiddleware.SetEndpointSource(ctx, endpoint.Source)
ctx = smithyhttp.SetHostnameImmutable(ctx, endpoint.HostnameImmutable)
ctx = awsmiddleware.SetSigningRegion(ctx, endpoint.SigningRegion)
ctx = awsmiddleware.SetPartitionID(ctx, endpoint.PartitionID)
return next.HandleSerialize(ctx, in)
}
func addResolveEndpointMiddleware(stack *middleware.Stack, o Options) error {
return stack.Serialize.Insert(&ResolveEndpoint{
Resolver: o.EndpointResolver,
Options: o.EndpointOptions,
}, "OperationSerializer", middleware.Before)
}
func removeResolveEndpointMiddleware(stack *middleware.Stack) error {
_, err := stack.Serialize.Remove((&ResolveEndpoint{}).ID())
return err
}
type wrappedEndpointResolver struct {
awsResolver aws.EndpointResolverWithOptions
resolver EndpointResolver
}
func (w *wrappedEndpointResolver) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
if w.awsResolver == nil {
goto fallback
}
endpoint, err = w.awsResolver.ResolveEndpoint(ServiceID, region, options)
if err == nil {
return endpoint, nil
}
if nf := (&aws.EndpointNotFoundError{}); !errors.As(err, &nf) {
return endpoint, err
}
fallback:
if w.resolver == nil {
return endpoint, fmt.Errorf("default endpoint resolver provided was nil")
}
return w.resolver.ResolveEndpoint(region, options)
}
type awsEndpointResolverAdaptor func(service, region string) (aws.Endpoint, error)
func (a awsEndpointResolverAdaptor) ResolveEndpoint(service, region string, options ...interface{}) (aws.Endpoint, error) {
return a(service, region)
}
var _ aws.EndpointResolverWithOptions = awsEndpointResolverAdaptor(nil)
// withEndpointResolver returns an EndpointResolver that first delegates endpoint resolution to the awsResolver.
// If awsResolver returns aws.EndpointNotFoundError error, the resolver will use the the provided
// fallbackResolver for resolution.
//
// fallbackResolver must not be nil
func withEndpointResolver(awsResolver aws.EndpointResolver, awsResolverWithOptions aws.EndpointResolverWithOptions, fallbackResolver EndpointResolver) EndpointResolver {
var resolver aws.EndpointResolverWithOptions
if awsResolverWithOptions != nil {
resolver = awsResolverWithOptions
} else if awsResolver != nil {
resolver = awsEndpointResolverAdaptor(awsResolver.ResolveEndpoint)
}
return &wrappedEndpointResolver{
awsResolver: resolver,
resolver: fallbackResolver,
}
}
func finalizeClientEndpointResolverOptions(options *Options) {
options.EndpointOptions.LogDeprecated = options.ClientLogMode.IsDeprecatedUsage()
if len(options.EndpointOptions.ResolvedRegion) == 0 {
const fipsInfix = "-fips-"
const fipsPrefix = "fips-"
const fipsSuffix = "-fips"
if strings.Contains(options.Region, fipsInfix) ||
strings.Contains(options.Region, fipsPrefix) ||
strings.Contains(options.Region, fipsSuffix) {
options.EndpointOptions.ResolvedRegion = strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(
options.Region, fipsInfix, "-"), fipsPrefix, ""), fipsSuffix, "")
options.EndpointOptions.UseFIPSEndpoint = aws.FIPSEndpointStateEnabled
}
}
}
| 201 |
aws-sdk-go-v2 | aws | Go | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT.
package sagemakerruntime
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.19.8"
| 7 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerruntime
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerruntime
import (
"bytes"
"context"
"fmt"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/encoding/httpbinding"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
type awsRestjson1_serializeOpInvokeEndpoint struct {
}
func (*awsRestjson1_serializeOpInvokeEndpoint) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpInvokeEndpoint) 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.(*InvokeEndpointInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/endpoints/{EndpointName}/invocations")
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}
}
if err := awsRestjson1_serializeOpHttpBindingsInvokeEndpointInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if !restEncoder.HasHeader("Content-Type") {
ctx = smithyhttp.SetIsContentTypeDefaultValue(ctx, true)
restEncoder.SetHeader("Content-Type").String("application/octet-stream")
}
if input.Body != nil {
payload := bytes.NewReader(input.Body)
if request, err = request.SetStream(payload); 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_serializeOpHttpBindingsInvokeEndpointInput(v *InvokeEndpointInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Accept != nil && len(*v.Accept) > 0 {
locationName := "Accept"
encoder.SetHeader(locationName).String(*v.Accept)
}
if v.ContentType != nil && len(*v.ContentType) > 0 {
locationName := "Content-Type"
encoder.SetHeader(locationName).String(*v.ContentType)
}
if v.CustomAttributes != nil && len(*v.CustomAttributes) > 0 {
locationName := "X-Amzn-Sagemaker-Custom-Attributes"
encoder.SetHeader(locationName).String(*v.CustomAttributes)
}
if v.EnableExplanations != nil && len(*v.EnableExplanations) > 0 {
locationName := "X-Amzn-Sagemaker-Enable-Explanations"
encoder.SetHeader(locationName).String(*v.EnableExplanations)
}
if v.EndpointName == nil || len(*v.EndpointName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member EndpointName must not be empty")}
}
if v.EndpointName != nil {
if err := encoder.SetURI("EndpointName").String(*v.EndpointName); err != nil {
return err
}
}
if v.InferenceId != nil && len(*v.InferenceId) > 0 {
locationName := "X-Amzn-Sagemaker-Inference-Id"
encoder.SetHeader(locationName).String(*v.InferenceId)
}
if v.TargetContainerHostname != nil && len(*v.TargetContainerHostname) > 0 {
locationName := "X-Amzn-Sagemaker-Target-Container-Hostname"
encoder.SetHeader(locationName).String(*v.TargetContainerHostname)
}
if v.TargetModel != nil && len(*v.TargetModel) > 0 {
locationName := "X-Amzn-Sagemaker-Target-Model"
encoder.SetHeader(locationName).String(*v.TargetModel)
}
if v.TargetVariant != nil && len(*v.TargetVariant) > 0 {
locationName := "X-Amzn-Sagemaker-Target-Variant"
encoder.SetHeader(locationName).String(*v.TargetVariant)
}
return nil
}
type awsRestjson1_serializeOpInvokeEndpointAsync struct {
}
func (*awsRestjson1_serializeOpInvokeEndpointAsync) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpInvokeEndpointAsync) 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.(*InvokeEndpointAsyncInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/endpoints/{EndpointName}/async-invocations")
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}
}
if err := awsRestjson1_serializeOpHttpBindingsInvokeEndpointAsyncInput(input, restEncoder); 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_serializeOpHttpBindingsInvokeEndpointAsyncInput(v *InvokeEndpointAsyncInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Accept != nil && len(*v.Accept) > 0 {
locationName := "X-Amzn-Sagemaker-Accept"
encoder.SetHeader(locationName).String(*v.Accept)
}
if v.ContentType != nil && len(*v.ContentType) > 0 {
locationName := "X-Amzn-Sagemaker-Content-Type"
encoder.SetHeader(locationName).String(*v.ContentType)
}
if v.CustomAttributes != nil && len(*v.CustomAttributes) > 0 {
locationName := "X-Amzn-Sagemaker-Custom-Attributes"
encoder.SetHeader(locationName).String(*v.CustomAttributes)
}
if v.EndpointName == nil || len(*v.EndpointName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member EndpointName must not be empty")}
}
if v.EndpointName != nil {
if err := encoder.SetURI("EndpointName").String(*v.EndpointName); err != nil {
return err
}
}
if v.InferenceId != nil && len(*v.InferenceId) > 0 {
locationName := "X-Amzn-Sagemaker-Inference-Id"
encoder.SetHeader(locationName).String(*v.InferenceId)
}
if v.InputLocation != nil && len(*v.InputLocation) > 0 {
locationName := "X-Amzn-Sagemaker-Inputlocation"
encoder.SetHeader(locationName).String(*v.InputLocation)
}
if v.InvocationTimeoutSeconds != nil {
locationName := "X-Amzn-Sagemaker-Invocationtimeoutseconds"
encoder.SetHeader(locationName).Integer(*v.InvocationTimeoutSeconds)
}
if v.RequestTTLSeconds != nil {
locationName := "X-Amzn-Sagemaker-Requestttlseconds"
encoder.SetHeader(locationName).Integer(*v.RequestTTLSeconds)
}
return nil
}
| 217 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemakerruntime
import (
"context"
"fmt"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpInvokeEndpointAsync struct {
}
func (*validateOpInvokeEndpointAsync) ID() string {
return "OperationInputValidation"
}
func (m *validateOpInvokeEndpointAsync) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*InvokeEndpointAsyncInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpInvokeEndpointAsyncInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpInvokeEndpoint struct {
}
func (*validateOpInvokeEndpoint) ID() string {
return "OperationInputValidation"
}
func (m *validateOpInvokeEndpoint) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*InvokeEndpointInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpInvokeEndpointInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpInvokeEndpointAsyncValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpInvokeEndpointAsync{}, middleware.After)
}
func addOpInvokeEndpointValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpInvokeEndpoint{}, middleware.After)
}
func validateOpInvokeEndpointAsyncInput(v *InvokeEndpointAsyncInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "InvokeEndpointAsyncInput"}
if v.EndpointName == nil {
invalidParams.Add(smithy.NewErrParamRequired("EndpointName"))
}
if v.InputLocation == nil {
invalidParams.Add(smithy.NewErrParamRequired("InputLocation"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpInvokeEndpointInput(v *InvokeEndpointInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "InvokeEndpointInput"}
if v.EndpointName == nil {
invalidParams.Add(smithy.NewErrParamRequired("EndpointName"))
}
if v.Body == nil {
invalidParams.Add(smithy.NewErrParamRequired("Body"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 95 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"github.com/aws/aws-sdk-go-v2/aws"
endpoints "github.com/aws/aws-sdk-go-v2/internal/endpoints/v2"
"github.com/aws/smithy-go/logging"
"regexp"
)
// Options is the endpoint resolver configuration options
type Options struct {
// Logger is a logging implementation that log events should be sent to.
Logger logging.Logger
// LogDeprecated indicates that deprecated endpoints should be logged to the
// provided logger.
LogDeprecated bool
// ResolvedRegion is used to override the region to be resolved, rather then the
// using the value passed to the ResolveEndpoint method. This value is used by the
// SDK to translate regions like fips-us-east-1 or us-east-1-fips to an alternative
// name. You must not set this value directly in your application.
ResolvedRegion string
// DisableHTTPS informs the resolver to return an endpoint that does not use the
// HTTPS scheme.
DisableHTTPS bool
// UseDualStackEndpoint specifies the resolver must resolve a dual-stack endpoint.
UseDualStackEndpoint aws.DualStackEndpointState
// UseFIPSEndpoint specifies the resolver must resolve a FIPS endpoint.
UseFIPSEndpoint aws.FIPSEndpointState
}
func (o Options) GetResolvedRegion() string {
return o.ResolvedRegion
}
func (o Options) GetDisableHTTPS() bool {
return o.DisableHTTPS
}
func (o Options) GetUseDualStackEndpoint() aws.DualStackEndpointState {
return o.UseDualStackEndpoint
}
func (o Options) GetUseFIPSEndpoint() aws.FIPSEndpointState {
return o.UseFIPSEndpoint
}
func transformToSharedOptions(options Options) endpoints.Options {
return endpoints.Options{
Logger: options.Logger,
LogDeprecated: options.LogDeprecated,
ResolvedRegion: options.ResolvedRegion,
DisableHTTPS: options.DisableHTTPS,
UseDualStackEndpoint: options.UseDualStackEndpoint,
UseFIPSEndpoint: options.UseFIPSEndpoint,
}
}
// Resolver SageMaker Runtime endpoint resolver
type Resolver struct {
partitions endpoints.Partitions
}
// ResolveEndpoint resolves the service endpoint for the given region and options
func (r *Resolver) ResolveEndpoint(region string, options Options) (endpoint aws.Endpoint, err error) {
if len(region) == 0 {
return endpoint, &aws.MissingRegionError{}
}
opt := transformToSharedOptions(options)
return r.partitions.ResolveEndpoint(region, opt)
}
// New returns a new Resolver
func New() *Resolver {
return &Resolver{
partitions: defaultPartitions,
}
}
var partitionRegexp = struct {
Aws *regexp.Regexp
AwsCn *regexp.Regexp
AwsIso *regexp.Regexp
AwsIsoB *regexp.Regexp
AwsIsoE *regexp.Regexp
AwsIsoF *regexp.Regexp
AwsUsGov *regexp.Regexp
}{
Aws: regexp.MustCompile("^(us|eu|ap|sa|ca|me|af)\\-\\w+\\-\\d+$"),
AwsCn: regexp.MustCompile("^cn\\-\\w+\\-\\d+$"),
AwsIso: regexp.MustCompile("^us\\-iso\\-\\w+\\-\\d+$"),
AwsIsoB: regexp.MustCompile("^us\\-isob\\-\\w+\\-\\d+$"),
AwsIsoE: regexp.MustCompile("^eu\\-isoe\\-\\w+\\-\\d+$"),
AwsIsoF: regexp.MustCompile("^us\\-isof\\-\\w+\\-\\d+$"),
AwsUsGov: regexp.MustCompile("^us\\-gov\\-\\w+\\-\\d+$"),
}
var defaultPartitions = endpoints.Partitions{
{
ID: "aws",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "runtime.sagemaker.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "runtime-fips.sagemaker.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "runtime.sagemaker-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "runtime.sagemaker.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
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-northeast-3",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-south-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-3",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-4",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ca-central-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-central-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-central-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-north-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-south-2",
}: 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: "me-central-1",
}: endpoints.Endpoint{},
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: "runtime-fips.sagemaker.us-east-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-east-1-fips",
}: endpoints.Endpoint{
Hostname: "runtime-fips.sagemaker.us-east-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-east-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "us-east-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-east-2",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "runtime-fips.sagemaker.us-east-2.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-east-2-fips",
}: endpoints.Endpoint{
Hostname: "runtime-fips.sagemaker.us-east-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-east-2",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "us-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-west-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "runtime-fips.sagemaker.us-west-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-west-1-fips",
}: endpoints.Endpoint{
Hostname: "runtime-fips.sagemaker.us-west-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-west-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "us-west-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-west-2",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "runtime-fips.sagemaker.us-west-2.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-west-2-fips",
}: endpoints.Endpoint{
Hostname: "runtime-fips.sagemaker.us-west-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-west-2",
},
Deprecated: aws.TrueTernary,
},
},
},
{
ID: "aws-cn",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "runtime.sagemaker.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "runtime.sagemaker-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "runtime.sagemaker-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "runtime.sagemaker.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
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",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "runtime.sagemaker-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "runtime.sagemaker.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIso,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "us-iso-east-1",
}: endpoints.Endpoint{},
},
},
{
ID: "aws-iso-b",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "runtime.sagemaker-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "runtime.sagemaker.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoB,
IsRegionalized: true,
},
{
ID: "aws-iso-e",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "runtime.sagemaker-fips.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "runtime.sagemaker.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoE,
IsRegionalized: true,
},
{
ID: "aws-iso-f",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "runtime.sagemaker-fips.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "runtime.sagemaker.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsIsoF,
IsRegionalized: true,
},
{
ID: "aws-us-gov",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "runtime.sagemaker.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "runtime.sagemaker.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "runtime.sagemaker-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "runtime.sagemaker.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "us-gov-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-gov-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-gov-west-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "runtime.sagemaker.us-gov-west-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-gov-west-1-fips",
}: endpoints.Endpoint{
Hostname: "runtime.sagemaker.us-gov-west-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-gov-west-1",
},
Deprecated: aws.TrueTernary,
},
},
},
}
| 476 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package endpoints
import (
"testing"
)
func TestRegexCompile(t *testing.T) {
_ = defaultPartitions
}
| 12 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
"fmt"
smithy "github.com/aws/smithy-go"
)
// Your request caused an exception with an internal dependency. Contact customer
// support.
type InternalDependencyException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InternalDependencyException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InternalDependencyException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InternalDependencyException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InternalDependencyException"
}
return *e.ErrorCodeOverride
}
func (e *InternalDependencyException) ErrorFault() smithy.ErrorFault { return smithy.FaultServer }
// An internal failure occurred.
type InternalFailure struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InternalFailure) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InternalFailure) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InternalFailure) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InternalFailure"
}
return *e.ErrorCodeOverride
}
func (e *InternalFailure) ErrorFault() smithy.ErrorFault { return smithy.FaultServer }
// Model (owned by the customer in the container) returned 4xx or 5xx error code.
type ModelError struct {
Message *string
ErrorCodeOverride *string
OriginalStatusCode *int32
OriginalMessage *string
LogStreamArn *string
noSmithyDocumentSerde
}
func (e *ModelError) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ModelError) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ModelError) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ModelError"
}
return *e.ErrorCodeOverride
}
func (e *ModelError) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// Either a serverless endpoint variant's resources are still being provisioned,
// or a multi-model endpoint is still downloading or loading the target model. Wait
// and try your request again.
type ModelNotReadyException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ModelNotReadyException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ModelNotReadyException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ModelNotReadyException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ModelNotReadyException"
}
return *e.ErrorCodeOverride
}
func (e *ModelNotReadyException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The service is unavailable. Try your call again.
type ServiceUnavailable struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ServiceUnavailable) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ServiceUnavailable) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ServiceUnavailable) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ServiceUnavailable"
}
return *e.ErrorCodeOverride
}
func (e *ServiceUnavailable) ErrorFault() smithy.ErrorFault { return smithy.FaultServer }
// Inspect your request and try again.
type ValidationError struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ValidationError) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ValidationError) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ValidationError) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ValidationError"
}
return *e.ErrorCodeOverride
}
func (e *ValidationError) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
| 172 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
smithydocument "github.com/aws/smithy-go/document"
)
type noSmithyDocumentSerde = smithydocument.NoSerde
| 10 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package savingsplans
import (
"context"
cryptorand "crypto/rand"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/aws/defaults"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/retry"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources"
smithy "github.com/aws/smithy-go"
smithydocument "github.com/aws/smithy-go/document"
"github.com/aws/smithy-go/logging"
"github.com/aws/smithy-go/middleware"
smithyrand "github.com/aws/smithy-go/rand"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net"
"net/http"
"time"
)
const ServiceID = "savingsplans"
const ServiceAPIVersion = "2019-06-28"
// Client provides the API client to make operations call for AWS Savings Plans.
type Client struct {
options Options
}
// 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 New(options Options, optFns ...func(*Options)) *Client {
options = options.Copy()
resolveDefaultLogger(&options)
setResolvedDefaultsMode(&options)
resolveRetryer(&options)
resolveHTTPClient(&options)
resolveHTTPSignerV4(&options)
resolveDefaultEndpointConfiguration(&options)
resolveIdempotencyTokenProvider(&options)
for _, fn := range optFns {
fn(&options)
}
client := &Client{
options: options,
}
return client
}
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 configuration DefaultsMode that the SDK should use when constructing the
// clients initial default settings.
DefaultsMode aws.DefaultsMode
// 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
// Provides idempotency tokens values that will be automatically populated into
// idempotent API operations.
IdempotencyTokenProvider IdempotencyTokenProvider
// The logger writer interface to write logging messages to.
Logger logging.Logger
// The region to send requests to. (Required)
Region string
// RetryMaxAttempts specifies the maximum number attempts an API client will call
// an operation that fails with a retryable error. A value of 0 is ignored, and
// will not be used to configure the API client created default retryer, or modify
// per operation call's retry max attempts. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. If specified in an operation call's functional
// options with a value that is different than the constructed client's Options,
// the Client's Retryer will be wrapped to use the operation's specific
// RetryMaxAttempts value.
RetryMaxAttempts int
// RetryMode specifies the retry mode the API client will be created with, if
// Retryer option is not also specified. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. Currently does not support per operation call
// overrides, may in the future.
RetryMode aws.RetryMode
// Retryer guides how HTTP requests should be retried in case of recoverable
// failures. When nil the API client will use a default retryer. The kind of
// default retry created by the API client can be changed with the RetryMode
// option.
Retryer aws.Retryer
// The RuntimeEnvironment configuration, only populated if the DefaultsMode is set
// to DefaultsModeAuto and is initialized using config.LoadDefaultConfig . You
// should not populate this structure programmatically, or rely on the values here
// within your applications.
RuntimeEnvironment aws.RuntimeEnvironment
// The initial DefaultsMode used when the client options were constructed. If the
// DefaultsMode was set to aws.DefaultsModeAuto this will store what the resolved
// value was at that point in time. Currently does not support per operation call
// overrides, may in the future.
resolvedDefaultsMode aws.DefaultsMode
// The HTTP client to invoke API calls with. Defaults to client's default HTTP
// implementation if nil.
HTTPClient HTTPClient
}
// WithAPIOptions returns a functional option for setting the Client's APIOptions
// option.
func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options) {
return func(o *Options) {
o.APIOptions = append(o.APIOptions, optFns...)
}
}
// WithEndpointResolver returns a functional option for setting the Client's
// EndpointResolver option.
func WithEndpointResolver(v EndpointResolver) func(*Options) {
return func(o *Options) {
o.EndpointResolver = v
}
}
type HTTPClient interface {
Do(*http.Request) (*http.Response, error)
}
// Copy creates a clone where the APIOptions list is deep copied.
func (o Options) Copy() Options {
to := o
to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions))
copy(to.APIOptions, o.APIOptions)
return to
}
func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) {
ctx = middleware.ClearStackValues(ctx)
stack := middleware.NewStack(opID, smithyhttp.NewStackRequest)
options := c.options.Copy()
for _, fn := range optFns {
fn(&options)
}
finalizeRetryMaxAttemptOptions(&options, *c)
finalizeClientEndpointResolverOptions(&options)
for _, fn := range stackFns {
if err := fn(stack, options); err != nil {
return nil, metadata, err
}
}
for _, fn := range options.APIOptions {
if err := fn(stack); err != nil {
return nil, metadata, err
}
}
handler := middleware.DecorateHandler(smithyhttp.NewClientHandler(options.HTTPClient), stack)
result, metadata, err = handler.Handle(ctx, params)
if err != nil {
err = &smithy.OperationError{
ServiceID: ServiceID,
OperationName: opID,
Err: err,
}
}
return result, metadata, err
}
type noSmithyDocumentSerde = smithydocument.NoSerde
func resolveDefaultLogger(o *Options) {
if o.Logger != nil {
return
}
o.Logger = logging.Nop{}
}
func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error {
return middleware.AddSetLoggerMiddleware(stack, o.Logger)
}
func setResolvedDefaultsMode(o *Options) {
if len(o.resolvedDefaultsMode) > 0 {
return
}
var mode aws.DefaultsMode
mode.SetFromString(string(o.DefaultsMode))
if mode == aws.DefaultsModeAuto {
mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment)
}
o.resolvedDefaultsMode = mode
}
// NewFromConfig returns a new client from the provided config.
func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client {
opts := Options{
Region: cfg.Region,
DefaultsMode: cfg.DefaultsMode,
RuntimeEnvironment: cfg.RuntimeEnvironment,
HTTPClient: cfg.HTTPClient,
Credentials: cfg.Credentials,
APIOptions: cfg.APIOptions,
Logger: cfg.Logger,
ClientLogMode: cfg.ClientLogMode,
}
resolveAWSRetryerProvider(cfg, &opts)
resolveAWSRetryMaxAttempts(cfg, &opts)
resolveAWSRetryMode(cfg, &opts)
resolveAWSEndpointResolver(cfg, &opts)
resolveUseDualStackEndpoint(cfg, &opts)
resolveUseFIPSEndpoint(cfg, &opts)
return New(opts, optFns...)
}
func resolveHTTPClient(o *Options) {
var buildable *awshttp.BuildableClient
if o.HTTPClient != nil {
var ok bool
buildable, ok = o.HTTPClient.(*awshttp.BuildableClient)
if !ok {
return
}
} else {
buildable = awshttp.NewBuildableClient()
}
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) {
if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok {
dialer.Timeout = dialerTimeout
}
})
buildable = buildable.WithTransportOptions(func(transport *http.Transport) {
if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok {
transport.TLSHandshakeTimeout = tlsHandshakeTimeout
}
})
}
o.HTTPClient = buildable
}
func resolveRetryer(o *Options) {
if o.Retryer != nil {
return
}
if len(o.RetryMode) == 0 {
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
o.RetryMode = modeConfig.RetryMode
}
}
if len(o.RetryMode) == 0 {
o.RetryMode = aws.RetryModeStandard
}
var standardOptions []func(*retry.StandardOptions)
if v := o.RetryMaxAttempts; v != 0 {
standardOptions = append(standardOptions, func(so *retry.StandardOptions) {
so.MaxAttempts = v
})
}
switch o.RetryMode {
case aws.RetryModeAdaptive:
var adaptiveOptions []func(*retry.AdaptiveModeOptions)
if len(standardOptions) != 0 {
adaptiveOptions = append(adaptiveOptions, func(ao *retry.AdaptiveModeOptions) {
ao.StandardOptions = append(ao.StandardOptions, standardOptions...)
})
}
o.Retryer = retry.NewAdaptiveMode(adaptiveOptions...)
default:
o.Retryer = retry.NewStandard(standardOptions...)
}
}
func resolveAWSRetryerProvider(cfg aws.Config, o *Options) {
if cfg.Retryer == nil {
return
}
o.Retryer = cfg.Retryer()
}
func resolveAWSRetryMode(cfg aws.Config, o *Options) {
if len(cfg.RetryMode) == 0 {
return
}
o.RetryMode = cfg.RetryMode
}
func resolveAWSRetryMaxAttempts(cfg aws.Config, o *Options) {
if cfg.RetryMaxAttempts == 0 {
return
}
o.RetryMaxAttempts = cfg.RetryMaxAttempts
}
func finalizeRetryMaxAttemptOptions(o *Options, client Client) {
if v := o.RetryMaxAttempts; v == 0 || v == client.options.RetryMaxAttempts {
return
}
o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts)
}
func resolveAWSEndpointResolver(cfg aws.Config, o *Options) {
if cfg.EndpointResolver == nil && cfg.EndpointResolverWithOptions == nil {
return
}
o.EndpointResolver = withEndpointResolver(cfg.EndpointResolver, cfg.EndpointResolverWithOptions, NewDefaultEndpointResolver())
}
func addClientUserAgent(stack *middleware.Stack) error {
return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "savingsplans", goModuleVersion)(stack)
}
func addHTTPSignerV4Middleware(stack *middleware.Stack, o Options) error {
mw := v4.NewSignHTTPRequestMiddleware(v4.SignHTTPRequestMiddlewareOptions{
CredentialsProvider: o.Credentials,
Signer: o.HTTPSignerV4,
LogSigning: o.ClientLogMode.IsSigning(),
})
return stack.Finalize.Add(mw, middleware.After)
}
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
}
func resolveHTTPSignerV4(o *Options) {
if o.HTTPSignerV4 != nil {
return
}
o.HTTPSignerV4 = newDefaultV4Signer(*o)
}
func newDefaultV4Signer(o Options) *v4.Signer {
return v4.NewSigner(func(so *v4.SignerOptions) {
so.Logger = o.Logger
so.LogSigning = o.ClientLogMode.IsSigning()
})
}
func resolveIdempotencyTokenProvider(o *Options) {
if o.IdempotencyTokenProvider != nil {
return
}
o.IdempotencyTokenProvider = smithyrand.NewUUIDIdempotencyToken(cryptorand.Reader)
}
func addRetryMiddlewares(stack *middleware.Stack, o Options) error {
mo := retry.AddRetryMiddlewaresOptions{
Retryer: o.Retryer,
LogRetryAttempts: o.ClientLogMode.IsRetries(),
}
return retry.AddRetryMiddlewares(stack, mo)
}
// resolves dual-stack endpoint configuration
func resolveUseDualStackEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseDualStackEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseDualStackEndpoint = value
}
return nil
}
// resolves FIPS endpoint configuration
func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseFIPSEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseFIPSEndpoint = value
}
return nil
}
// IdempotencyTokenProvider interface for providing idempotency token
type IdempotencyTokenProvider interface {
GetIdempotencyToken() (string, error)
}
func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error {
return awsmiddleware.AddRequestIDRetrieverMiddleware(stack)
}
func addResponseErrorMiddleware(stack *middleware.Stack) error {
return awshttp.AddResponseErrorMiddleware(stack)
}
func addRequestResponseLogging(stack *middleware.Stack, o Options) error {
return stack.Deserialize.Add(&smithyhttp.RequestResponseLogger{
LogRequest: o.ClientLogMode.IsRequest(),
LogRequestWithBody: o.ClientLogMode.IsRequestWithBody(),
LogResponse: o.ClientLogMode.IsResponse(),
LogResponseWithBody: o.ClientLogMode.IsResponseWithBody(),
}, middleware.After)
}
| 454 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package savingsplans
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io/ioutil"
"net/http"
"strings"
"testing"
)
func TestClient_resolveRetryOptions(t *testing.T) {
nopClient := smithyhttp.ClientDoFunc(func(_ *http.Request) (*http.Response, error) {
return &http.Response{
StatusCode: 200,
Header: http.Header{},
Body: ioutil.NopCloser(strings.NewReader("")),
}, nil
})
cases := map[string]struct {
defaultsMode aws.DefaultsMode
retryer aws.Retryer
retryMaxAttempts int
opRetryMaxAttempts *int
retryMode aws.RetryMode
expectClientRetryMode aws.RetryMode
expectClientMaxAttempts int
expectOpMaxAttempts int
}{
"defaults": {
defaultsMode: aws.DefaultsModeStandard,
expectClientRetryMode: aws.RetryModeStandard,
expectClientMaxAttempts: 3,
expectOpMaxAttempts: 3,
},
"custom default retry": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(2),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 2,
},
"custom op no change max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(10),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op 0 max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(0),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
client := NewFromConfig(aws.Config{
DefaultsMode: c.defaultsMode,
Retryer: func() func() aws.Retryer {
if c.retryer == nil {
return nil
}
return func() aws.Retryer { return c.retryer }
}(),
HTTPClient: nopClient,
RetryMaxAttempts: c.retryMaxAttempts,
RetryMode: c.retryMode,
})
if e, a := c.expectClientRetryMode, client.options.RetryMode; e != a {
t.Errorf("expect %v retry mode, got %v", e, a)
}
if e, a := c.expectClientMaxAttempts, client.options.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v max attempts, got %v", e, a)
}
_, _, err := client.invokeOperation(context.Background(), "mockOperation", struct{}{},
[]func(*Options){
func(o *Options) {
if c.opRetryMaxAttempts == nil {
return
}
o.RetryMaxAttempts = *c.opRetryMaxAttempts
},
},
func(s *middleware.Stack, o Options) error {
s.Initialize.Clear()
s.Serialize.Clear()
s.Build.Clear()
s.Finalize.Clear()
s.Deserialize.Clear()
if e, a := c.expectOpMaxAttempts, o.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v op max attempts, got %v", e, a)
}
return nil
})
if err != nil {
t.Fatalf("expect no operation error, got %v", err)
}
})
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package savingsplans
import (
"context"
"fmt"
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"
"time"
)
// Creates a Savings Plan.
func (c *Client) CreateSavingsPlan(ctx context.Context, params *CreateSavingsPlanInput, optFns ...func(*Options)) (*CreateSavingsPlanOutput, error) {
if params == nil {
params = &CreateSavingsPlanInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateSavingsPlan", params, optFns, c.addOperationCreateSavingsPlanMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateSavingsPlanOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateSavingsPlanInput struct {
// The hourly commitment, in USD. This is a value between 0.001 and 1 million. You
// cannot specify more than five digits after the decimal point.
//
// This member is required.
Commitment *string
// The ID of the offering.
//
// This member is required.
SavingsPlanOfferingId *string
// Unique, case-sensitive identifier that you provide to ensure the idempotency of
// the request.
ClientToken *string
// The time at which to purchase the Savings Plan, in UTC format
// (YYYY-MM-DDTHH:MM:SSZ).
PurchaseTime *time.Time
// One or more tags.
Tags map[string]string
// The up-front payment amount. This is a whole number between 50 and 99 percent
// of the total value of the Savings Plan. This parameter is supported only if the
// payment option is Partial Upfront .
UpfrontPaymentAmount *string
noSmithyDocumentSerde
}
type CreateSavingsPlanOutput struct {
// The ID of the Savings Plan.
SavingsPlanId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateSavingsPlanMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateSavingsPlan{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateSavingsPlan{}, 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 = addIdempotencyToken_opCreateSavingsPlanMiddleware(stack, options); err != nil {
return err
}
if err = addOpCreateSavingsPlanValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateSavingsPlan(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
}
type idempotencyToken_initializeOpCreateSavingsPlan struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpCreateSavingsPlan) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpCreateSavingsPlan) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*CreateSavingsPlanInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateSavingsPlanInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opCreateSavingsPlanMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpCreateSavingsPlan{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opCreateSavingsPlan(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "savingsplans",
OperationName: "CreateSavingsPlan",
}
}
| 184 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package savingsplans
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"
)
// Deletes the queued purchase for the specified Savings Plan.
func (c *Client) DeleteQueuedSavingsPlan(ctx context.Context, params *DeleteQueuedSavingsPlanInput, optFns ...func(*Options)) (*DeleteQueuedSavingsPlanOutput, error) {
if params == nil {
params = &DeleteQueuedSavingsPlanInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteQueuedSavingsPlan", params, optFns, c.addOperationDeleteQueuedSavingsPlanMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteQueuedSavingsPlanOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteQueuedSavingsPlanInput struct {
// The ID of the Savings Plan.
//
// This member is required.
SavingsPlanId *string
noSmithyDocumentSerde
}
type DeleteQueuedSavingsPlanOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteQueuedSavingsPlanMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteQueuedSavingsPlan{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteQueuedSavingsPlan{}, 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 = addOpDeleteQueuedSavingsPlanValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteQueuedSavingsPlan(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_opDeleteQueuedSavingsPlan(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "savingsplans",
OperationName: "DeleteQueuedSavingsPlan",
}
}
| 120 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.