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 iotdataplane provides the API client, operations, and parameter types
// for AWS IoT Data Plane.
//
// IoT data IoT data enables secure, bi-directional communication between
// Internet-connected things (such as sensors, actuators, embedded devices, or
// smart appliances) and the Amazon Web Services cloud. It implements a broker for
// applications and things to publish messages over HTTP (Publish) and retrieve,
// update, and delete shadows. A shadow is a persistent representation of your
// things and their state in the Amazon Web Services cloud. Find the endpoint
// address for actions in IoT data by running this CLI command: aws iot
// describe-endpoint --endpoint-type iot:Data-ATS The service name used by Amazon
// Web ServicesSignature Version 4 (https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html)
// to sign requests is: iotdevicegateway.
package iotdataplane
| 17 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdataplane
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/iotdataplane/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 = "iotdata"
}
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 iotdataplane
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.15.4"
| 7 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdataplane
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdataplane
import (
"bytes"
"context"
"encoding/base64"
"fmt"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/encoding/httpbinding"
"github.com/aws/smithy-go/middleware"
"github.com/aws/smithy-go/ptr"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
type awsRestjson1_serializeOpDeleteThingShadow struct {
}
func (*awsRestjson1_serializeOpDeleteThingShadow) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteThingShadow) 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.(*DeleteThingShadowInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/things/{thingName}/shadow")
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_serializeOpHttpBindingsDeleteThingShadowInput(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_serializeOpHttpBindingsDeleteThingShadowInput(v *DeleteThingShadowInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ShadowName != nil {
encoder.SetQuery("name").String(*v.ShadowName)
}
if v.ThingName == nil || len(*v.ThingName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member thingName must not be empty")}
}
if v.ThingName != nil {
if err := encoder.SetURI("thingName").String(*v.ThingName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetRetainedMessage struct {
}
func (*awsRestjson1_serializeOpGetRetainedMessage) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetRetainedMessage) 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.(*GetRetainedMessageInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/retainedMessage/{topic}")
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_serializeOpHttpBindingsGetRetainedMessageInput(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_serializeOpHttpBindingsGetRetainedMessageInput(v *GetRetainedMessageInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Topic == nil || len(*v.Topic) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member topic must not be empty")}
}
if v.Topic != nil {
if err := encoder.SetURI("topic").String(*v.Topic); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetThingShadow struct {
}
func (*awsRestjson1_serializeOpGetThingShadow) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetThingShadow) 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.(*GetThingShadowInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/things/{thingName}/shadow")
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_serializeOpHttpBindingsGetThingShadowInput(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_serializeOpHttpBindingsGetThingShadowInput(v *GetThingShadowInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ShadowName != nil {
encoder.SetQuery("name").String(*v.ShadowName)
}
if v.ThingName == nil || len(*v.ThingName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member thingName must not be empty")}
}
if v.ThingName != nil {
if err := encoder.SetURI("thingName").String(*v.ThingName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListNamedShadowsForThing struct {
}
func (*awsRestjson1_serializeOpListNamedShadowsForThing) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListNamedShadowsForThing) 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.(*ListNamedShadowsForThingInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/api/things/shadow/ListNamedShadowsForThing/{thingName}")
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_serializeOpHttpBindingsListNamedShadowsForThingInput(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_serializeOpHttpBindingsListNamedShadowsForThingInput(v *ListNamedShadowsForThingInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.PageSize != nil {
encoder.SetQuery("pageSize").Integer(*v.PageSize)
}
if v.ThingName == nil || len(*v.ThingName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member thingName must not be empty")}
}
if v.ThingName != nil {
if err := encoder.SetURI("thingName").String(*v.ThingName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListRetainedMessages struct {
}
func (*awsRestjson1_serializeOpListRetainedMessages) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListRetainedMessages) 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.(*ListRetainedMessagesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/retainedMessage")
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_serializeOpHttpBindingsListRetainedMessagesInput(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_serializeOpHttpBindingsListRetainedMessagesInput(v *ListRetainedMessagesInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpPublish struct {
}
func (*awsRestjson1_serializeOpPublish) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpPublish) 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.(*PublishInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/topics/{topic}")
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_serializeOpHttpBindingsPublishInput(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.Payload != nil {
payload := bytes.NewReader(input.Payload)
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_serializeOpHttpBindingsPublishInput(v *PublishInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ContentType != nil {
encoder.SetQuery("contentType").String(*v.ContentType)
}
if v.CorrelationData != nil && len(*v.CorrelationData) > 0 {
locationName := "X-Amz-Mqtt5-Correlation-Data"
encoder.SetHeader(locationName).String(*v.CorrelationData)
}
if v.MessageExpiry != 0 {
encoder.SetQuery("messageExpiry").Long(v.MessageExpiry)
}
if len(v.PayloadFormatIndicator) > 0 {
locationName := "X-Amz-Mqtt5-Payload-Format-Indicator"
encoder.SetHeader(locationName).String(string(v.PayloadFormatIndicator))
}
if v.Qos != 0 {
encoder.SetQuery("qos").Integer(v.Qos)
}
if v.ResponseTopic != nil {
encoder.SetQuery("responseTopic").String(*v.ResponseTopic)
}
if v.Retain {
encoder.SetQuery("retain").Boolean(v.Retain)
}
if v.Topic == nil || len(*v.Topic) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member topic must not be empty")}
}
if v.Topic != nil {
if err := encoder.SetURI("topic").String(*v.Topic); err != nil {
return err
}
}
if v.UserProperties != nil && len(*v.UserProperties) > 0 {
locationName := "X-Amz-Mqtt5-User-Properties"
encodedVal := base64.StdEncoding.EncodeToString([]byte(*v.UserProperties))
encodedPtr := ptr.String(encodedVal)
encoder.SetHeader(locationName).String(*encodedPtr)
}
return nil
}
type awsRestjson1_serializeOpUpdateThingShadow struct {
}
func (*awsRestjson1_serializeOpUpdateThingShadow) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateThingShadow) 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.(*UpdateThingShadowInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/things/{thingName}/shadow")
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_serializeOpHttpBindingsUpdateThingShadowInput(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.Payload != nil {
payload := bytes.NewReader(input.Payload)
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_serializeOpHttpBindingsUpdateThingShadowInput(v *UpdateThingShadowInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ShadowName != nil {
encoder.SetQuery("name").String(*v.ShadowName)
}
if v.ThingName == nil || len(*v.ThingName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member thingName must not be empty")}
}
if v.ThingName != nil {
if err := encoder.SetURI("thingName").String(*v.ThingName); err != nil {
return err
}
}
return nil
}
| 502 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdataplane
import (
"context"
"fmt"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpDeleteThingShadow struct {
}
func (*validateOpDeleteThingShadow) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteThingShadow) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteThingShadowInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteThingShadowInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetRetainedMessage struct {
}
func (*validateOpGetRetainedMessage) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetRetainedMessage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetRetainedMessageInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetRetainedMessageInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetThingShadow struct {
}
func (*validateOpGetThingShadow) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetThingShadow) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetThingShadowInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetThingShadowInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListNamedShadowsForThing struct {
}
func (*validateOpListNamedShadowsForThing) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListNamedShadowsForThing) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListNamedShadowsForThingInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListNamedShadowsForThingInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpPublish struct {
}
func (*validateOpPublish) ID() string {
return "OperationInputValidation"
}
func (m *validateOpPublish) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*PublishInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpPublishInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateThingShadow struct {
}
func (*validateOpUpdateThingShadow) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateThingShadow) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateThingShadowInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateThingShadowInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpDeleteThingShadowValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteThingShadow{}, middleware.After)
}
func addOpGetRetainedMessageValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetRetainedMessage{}, middleware.After)
}
func addOpGetThingShadowValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetThingShadow{}, middleware.After)
}
func addOpListNamedShadowsForThingValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListNamedShadowsForThing{}, middleware.After)
}
func addOpPublishValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpPublish{}, middleware.After)
}
func addOpUpdateThingShadowValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateThingShadow{}, middleware.After)
}
func validateOpDeleteThingShadowInput(v *DeleteThingShadowInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteThingShadowInput"}
if v.ThingName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ThingName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetRetainedMessageInput(v *GetRetainedMessageInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetRetainedMessageInput"}
if v.Topic == nil {
invalidParams.Add(smithy.NewErrParamRequired("Topic"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetThingShadowInput(v *GetThingShadowInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetThingShadowInput"}
if v.ThingName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ThingName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListNamedShadowsForThingInput(v *ListNamedShadowsForThingInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListNamedShadowsForThingInput"}
if v.ThingName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ThingName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpPublishInput(v *PublishInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PublishInput"}
if v.Topic == nil {
invalidParams.Add(smithy.NewErrParamRequired("Topic"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateThingShadowInput(v *UpdateThingShadowInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateThingShadowInput"}
if v.ThingName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ThingName"))
}
if v.Payload == nil {
invalidParams.Add(smithy.NewErrParamRequired("Payload"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 248 |
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 IoT Data Plane 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: "data-ats.iot.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
CredentialScope: endpoints.CredentialScope{
Service: "iotdata",
},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "data-ats.iot-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
CredentialScope: endpoints.CredentialScope{
Service: "iotdata",
},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "data-ats.iot-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
CredentialScope: endpoints.CredentialScope{
Service: "iotdata",
},
},
{
Variant: 0,
}: {
Hostname: "data-ats.iot.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
CredentialScope: endpoints.CredentialScope{
Service: "iotdata",
},
},
},
RegionRegex: partitionRegexp.Aws,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "ap-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-northeast-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-northeast-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ca-central-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ca-central-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "data.iot-fips.ca-central-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "eu-central-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-north-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-3",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "fips-ca-central-1",
}: endpoints.Endpoint{
Hostname: "data.iot-fips.ca-central-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Service: "iotdata",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-us-east-1",
}: endpoints.Endpoint{
Hostname: "data.iot-fips.us-east-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Service: "iotdata",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-us-east-2",
}: endpoints.Endpoint{
Hostname: "data.iot-fips.us-east-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Service: "iotdata",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-us-west-1",
}: endpoints.Endpoint{
Hostname: "data.iot-fips.us-west-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Service: "iotdata",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-us-west-2",
}: endpoints.Endpoint{
Hostname: "data.iot-fips.us-west-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Service: "iotdata",
},
Deprecated: aws.TrueTernary,
},
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: "data.iot-fips.us-east-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-east-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-east-2",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "data.iot-fips.us-east-2.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-west-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "data.iot-fips.us-west-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-west-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-west-2",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "data.iot-fips.us-west-2.amazonaws.com",
},
},
},
{
ID: "aws-cn",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "data-ats.iot.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
CredentialScope: endpoints.CredentialScope{
Service: "iotdata",
},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "data-ats.iot-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
CredentialScope: endpoints.CredentialScope{
Service: "iotdata",
},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "data-ats.iot-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
CredentialScope: endpoints.CredentialScope{
Service: "iotdata",
},
},
{
Variant: 0,
}: {
Hostname: "data-ats.iot.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
CredentialScope: endpoints.CredentialScope{
Service: "iotdata",
},
},
},
RegionRegex: partitionRegexp.AwsCn,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "cn-north-1",
}: endpoints.Endpoint{
Hostname: "data.ats.iot.cn-north-1.amazonaws.com.cn",
Protocols: []string{"https"},
},
endpoints.EndpointKey{
Region: "cn-northwest-1",
}: endpoints.Endpoint{},
},
},
{
ID: "aws-iso",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "data-ats.iot-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "data-ats.iot.{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: "data-ats.iot-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "data-ats.iot.{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: "data-ats.iot-fips.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "data-ats.iot.{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: "data-ats.iot-fips.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "data-ats.iot.{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: "data-ats.iot.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
CredentialScope: endpoints.CredentialScope{
Service: "iotdata",
},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "data-ats.iot-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
CredentialScope: endpoints.CredentialScope{
Service: "iotdata",
},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "data-ats.iot-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
CredentialScope: endpoints.CredentialScope{
Service: "iotdata",
},
},
{
Variant: 0,
}: {
Hostname: "data-ats.iot.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
CredentialScope: endpoints.CredentialScope{
Service: "iotdata",
},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "fips-us-gov-east-1",
}: endpoints.Endpoint{
Hostname: "data.iot-fips.us-gov-east-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Service: "iotdata",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-us-gov-west-1",
}: endpoints.Endpoint{
Hostname: "data.iot-fips.us-gov-west-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Service: "iotdata",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "us-gov-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-gov-east-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "data.iot-fips.us-gov-east-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-gov-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-gov-west-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "data.iot-fips.us-gov-west-1.amazonaws.com",
},
},
},
}
| 516 |
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 PayloadFormatIndicator string
// Enum values for PayloadFormatIndicator
const (
PayloadFormatIndicatorUnspecifiedBytes PayloadFormatIndicator = "UNSPECIFIED_BYTES"
PayloadFormatIndicatorUtf8Data PayloadFormatIndicator = "UTF8_DATA"
)
// Values returns all known values for PayloadFormatIndicator. 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 (PayloadFormatIndicator) Values() []PayloadFormatIndicator {
return []PayloadFormatIndicator{
"UNSPECIFIED_BYTES",
"UTF8_DATA",
}
}
| 22 |
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"
)
// The specified version does not match the version of the document.
type ConflictException struct {
Message *string
ErrorCodeOverride *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 }
// An unexpected error has occurred.
type InternalFailureException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InternalFailureException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InternalFailureException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InternalFailureException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InternalFailureException"
}
return *e.ErrorCodeOverride
}
func (e *InternalFailureException) ErrorFault() smithy.ErrorFault { return smithy.FaultServer }
// The request is not valid.
type InvalidRequestException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidRequestException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidRequestException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidRequestException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidRequestException"
}
return *e.ErrorCodeOverride
}
func (e *InvalidRequestException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The specified combination of HTTP verb and URI is not supported.
type MethodNotAllowedException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *MethodNotAllowedException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *MethodNotAllowedException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *MethodNotAllowedException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "MethodNotAllowedException"
}
return *e.ErrorCodeOverride
}
func (e *MethodNotAllowedException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The payload exceeds the maximum size allowed.
type RequestEntityTooLargeException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *RequestEntityTooLargeException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *RequestEntityTooLargeException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *RequestEntityTooLargeException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "RequestEntityTooLargeException"
}
return *e.ErrorCodeOverride
}
func (e *RequestEntityTooLargeException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The specified resource does not exist.
type ResourceNotFoundException struct {
Message *string
ErrorCodeOverride *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 }
// The service is temporarily unavailable.
type ServiceUnavailableException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ServiceUnavailableException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ServiceUnavailableException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ServiceUnavailableException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ServiceUnavailableException"
}
return *e.ErrorCodeOverride
}
func (e *ServiceUnavailableException) ErrorFault() smithy.ErrorFault { return smithy.FaultServer }
// The rate exceeds the limit.
type ThrottlingException struct {
Message *string
ErrorCodeOverride *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 }
// You are not authorized to perform this operation.
type UnauthorizedException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *UnauthorizedException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *UnauthorizedException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *UnauthorizedException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "UnauthorizedException"
}
return *e.ErrorCodeOverride
}
func (e *UnauthorizedException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The document encoding is not supported.
type UnsupportedDocumentEncodingException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *UnsupportedDocumentEncodingException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *UnsupportedDocumentEncodingException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *UnsupportedDocumentEncodingException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "UnsupportedDocumentEncodingException"
}
return *e.ErrorCodeOverride
}
func (e *UnsupportedDocumentEncodingException) ErrorFault() smithy.ErrorFault {
return smithy.FaultClient
}
| 271 |
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"
)
// Information about a single retained message.
type RetainedMessageSummary struct {
// The Epoch date and time, in milliseconds, when the retained message was stored
// by IoT.
LastModifiedTime int64
// The size of the retained message's payload in bytes.
PayloadSize int64
// The quality of service (QoS) level used to publish the retained message.
Qos int32
// The topic name to which the retained message was published.
Topic *string
noSmithyDocumentSerde
}
type noSmithyDocumentSerde = smithydocument.NoSerde
| 29 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdeviceadvisor
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 = "IotDeviceAdvisor"
const ServiceAPIVersion = "2020-09-18"
// Client provides the API client to make operations call for AWS IoT Core Device
// Advisor.
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, "iotdeviceadvisor", 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 iotdeviceadvisor
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 iotdeviceadvisor
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/iotdeviceadvisor/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Creates a Device Advisor test suite. Requires permission to access the
// CreateSuiteDefinition (https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-actions-as-permissions)
// action.
func (c *Client) CreateSuiteDefinition(ctx context.Context, params *CreateSuiteDefinitionInput, optFns ...func(*Options)) (*CreateSuiteDefinitionOutput, error) {
if params == nil {
params = &CreateSuiteDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateSuiteDefinition", params, optFns, c.addOperationCreateSuiteDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateSuiteDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateSuiteDefinitionInput struct {
// Creates a Device Advisor test suite with suite definition configuration.
//
// This member is required.
SuiteDefinitionConfiguration *types.SuiteDefinitionConfiguration
// The tags to be attached to the suite definition.
Tags map[string]string
noSmithyDocumentSerde
}
type CreateSuiteDefinitionOutput struct {
// The timestamp of when the test suite was created.
CreatedAt *time.Time
// The Amazon Resource Name (ARN) of the test suite.
SuiteDefinitionArn *string
// The UUID of the test suite created.
SuiteDefinitionId *string
// The suite definition name of the test suite. This is a required parameter.
SuiteDefinitionName *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateSuiteDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateSuiteDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateSuiteDefinition{}, 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 = addOpCreateSuiteDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateSuiteDefinition(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_opCreateSuiteDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotdeviceadvisor",
OperationName: "CreateSuiteDefinition",
}
}
| 140 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdeviceadvisor
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 a Device Advisor test suite. Requires permission to access the
// DeleteSuiteDefinition (https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-actions-as-permissions)
// action.
func (c *Client) DeleteSuiteDefinition(ctx context.Context, params *DeleteSuiteDefinitionInput, optFns ...func(*Options)) (*DeleteSuiteDefinitionOutput, error) {
if params == nil {
params = &DeleteSuiteDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteSuiteDefinition", params, optFns, c.addOperationDeleteSuiteDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteSuiteDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteSuiteDefinitionInput struct {
// Suite definition ID of the test suite to be deleted.
//
// This member is required.
SuiteDefinitionId *string
noSmithyDocumentSerde
}
type DeleteSuiteDefinitionOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteSuiteDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteSuiteDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteSuiteDefinition{}, 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 = addOpDeleteSuiteDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteSuiteDefinition(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_opDeleteSuiteDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotdeviceadvisor",
OperationName: "DeleteSuiteDefinition",
}
}
| 122 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdeviceadvisor
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/iotdeviceadvisor/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets information about an Device Advisor endpoint.
func (c *Client) GetEndpoint(ctx context.Context, params *GetEndpointInput, optFns ...func(*Options)) (*GetEndpointOutput, error) {
if params == nil {
params = &GetEndpointInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetEndpoint", params, optFns, c.addOperationGetEndpointMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetEndpointOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetEndpointInput struct {
// The authentication method used during the device connection.
AuthenticationMethod types.AuthenticationMethod
// The certificate ARN of the device. This is an optional parameter.
CertificateArn *string
// The device role ARN of the device. This is an optional parameter.
DeviceRoleArn *string
// The thing ARN of the device. This is an optional parameter.
ThingArn *string
noSmithyDocumentSerde
}
type GetEndpointOutput struct {
// The response of an Device Advisor endpoint.
Endpoint *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetEndpointMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetEndpoint{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetEndpoint{}, 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_opGetEndpoint(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_opGetEndpoint(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotdeviceadvisor",
OperationName: "GetEndpoint",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdeviceadvisor
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/iotdeviceadvisor/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Gets information about a Device Advisor test suite. Requires permission to
// access the GetSuiteDefinition (https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-actions-as-permissions)
// action.
func (c *Client) GetSuiteDefinition(ctx context.Context, params *GetSuiteDefinitionInput, optFns ...func(*Options)) (*GetSuiteDefinitionOutput, error) {
if params == nil {
params = &GetSuiteDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetSuiteDefinition", params, optFns, c.addOperationGetSuiteDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetSuiteDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetSuiteDefinitionInput struct {
// Suite definition ID of the test suite to get.
//
// This member is required.
SuiteDefinitionId *string
// Suite definition version of the test suite to get.
SuiteDefinitionVersion *string
noSmithyDocumentSerde
}
type GetSuiteDefinitionOutput struct {
// Date (in Unix epoch time) when the suite definition was created.
CreatedAt *time.Time
// Date (in Unix epoch time) when the suite definition was last modified.
LastModifiedAt *time.Time
// Latest suite definition version of the suite definition.
LatestVersion *string
// The ARN of the suite definition.
SuiteDefinitionArn *string
// Suite configuration of the suite definition.
SuiteDefinitionConfiguration *types.SuiteDefinitionConfiguration
// Suite definition ID of the suite definition.
SuiteDefinitionId *string
// Suite definition version of the suite definition.
SuiteDefinitionVersion *string
// Tags attached to the suite definition.
Tags map[string]string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetSuiteDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetSuiteDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetSuiteDefinition{}, 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 = addOpGetSuiteDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetSuiteDefinition(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_opGetSuiteDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotdeviceadvisor",
OperationName: "GetSuiteDefinition",
}
}
| 152 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdeviceadvisor
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/iotdeviceadvisor/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Gets information about a Device Advisor test suite run. Requires permission to
// access the GetSuiteRun (https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-actions-as-permissions)
// action.
func (c *Client) GetSuiteRun(ctx context.Context, params *GetSuiteRunInput, optFns ...func(*Options)) (*GetSuiteRunOutput, error) {
if params == nil {
params = &GetSuiteRunInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetSuiteRun", params, optFns, c.addOperationGetSuiteRunMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetSuiteRunOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetSuiteRunInput struct {
// Suite definition ID for the test suite run.
//
// This member is required.
SuiteDefinitionId *string
// Suite run ID for the test suite run.
//
// This member is required.
SuiteRunId *string
noSmithyDocumentSerde
}
type GetSuiteRunOutput struct {
// Date (in Unix epoch time) when the test suite run ended.
EndTime *time.Time
// Error reason for any test suite run failure.
ErrorReason *string
// Date (in Unix epoch time) when the test suite run started.
StartTime *time.Time
// Status for the test suite run.
Status types.SuiteRunStatus
// Suite definition ID for the test suite run.
SuiteDefinitionId *string
// Suite definition version for the test suite run.
SuiteDefinitionVersion *string
// The ARN of the suite run.
SuiteRunArn *string
// Suite run configuration for the test suite run.
SuiteRunConfiguration *types.SuiteRunConfiguration
// Suite run ID for the test suite run.
SuiteRunId *string
// The tags attached to the suite run.
Tags map[string]string
// Test results for the test suite run.
TestResult *types.TestResult
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetSuiteRunMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetSuiteRun{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetSuiteRun{}, 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 = addOpGetSuiteRunValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetSuiteRun(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_opGetSuiteRun(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotdeviceadvisor",
OperationName: "GetSuiteRun",
}
}
| 163 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdeviceadvisor
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"
)
// Gets a report download link for a successful Device Advisor qualifying test
// suite run. Requires permission to access the GetSuiteRunReport (https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-actions-as-permissions)
// action.
func (c *Client) GetSuiteRunReport(ctx context.Context, params *GetSuiteRunReportInput, optFns ...func(*Options)) (*GetSuiteRunReportOutput, error) {
if params == nil {
params = &GetSuiteRunReportInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetSuiteRunReport", params, optFns, c.addOperationGetSuiteRunReportMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetSuiteRunReportOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetSuiteRunReportInput struct {
// Suite definition ID of the test suite.
//
// This member is required.
SuiteDefinitionId *string
// Suite run ID of the test suite run.
//
// This member is required.
SuiteRunId *string
noSmithyDocumentSerde
}
type GetSuiteRunReportOutput struct {
// Download URL of the qualification report.
QualificationReportDownloadUrl *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetSuiteRunReportMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetSuiteRunReport{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetSuiteRunReport{}, 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 = addOpGetSuiteRunReportValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetSuiteRunReport(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_opGetSuiteRunReport(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotdeviceadvisor",
OperationName: "GetSuiteRunReport",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdeviceadvisor
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/iotdeviceadvisor/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the Device Advisor test suites you have created. Requires permission to
// access the ListSuiteDefinitions (https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-actions-as-permissions)
// action.
func (c *Client) ListSuiteDefinitions(ctx context.Context, params *ListSuiteDefinitionsInput, optFns ...func(*Options)) (*ListSuiteDefinitionsOutput, error) {
if params == nil {
params = &ListSuiteDefinitionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListSuiteDefinitions", params, optFns, c.addOperationListSuiteDefinitionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListSuiteDefinitionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListSuiteDefinitionsInput struct {
// The maximum number of results to return at once.
MaxResults int32
// A token used to get the next set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListSuiteDefinitionsOutput struct {
// A token used to get the next set of results.
NextToken *string
// An array of objects that provide summaries of information about the suite
// definitions in the list.
SuiteDefinitionInformationList []types.SuiteDefinitionInformation
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListSuiteDefinitionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListSuiteDefinitions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListSuiteDefinitions{}, 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_opListSuiteDefinitions(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
}
// ListSuiteDefinitionsAPIClient is a client that implements the
// ListSuiteDefinitions operation.
type ListSuiteDefinitionsAPIClient interface {
ListSuiteDefinitions(context.Context, *ListSuiteDefinitionsInput, ...func(*Options)) (*ListSuiteDefinitionsOutput, error)
}
var _ ListSuiteDefinitionsAPIClient = (*Client)(nil)
// ListSuiteDefinitionsPaginatorOptions is the paginator options for
// ListSuiteDefinitions
type ListSuiteDefinitionsPaginatorOptions struct {
// The maximum number of results to return at once.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListSuiteDefinitionsPaginator is a paginator for ListSuiteDefinitions
type ListSuiteDefinitionsPaginator struct {
options ListSuiteDefinitionsPaginatorOptions
client ListSuiteDefinitionsAPIClient
params *ListSuiteDefinitionsInput
nextToken *string
firstPage bool
}
// NewListSuiteDefinitionsPaginator returns a new ListSuiteDefinitionsPaginator
func NewListSuiteDefinitionsPaginator(client ListSuiteDefinitionsAPIClient, params *ListSuiteDefinitionsInput, optFns ...func(*ListSuiteDefinitionsPaginatorOptions)) *ListSuiteDefinitionsPaginator {
if params == nil {
params = &ListSuiteDefinitionsInput{}
}
options := ListSuiteDefinitionsPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListSuiteDefinitionsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListSuiteDefinitionsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListSuiteDefinitions page.
func (p *ListSuiteDefinitionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListSuiteDefinitionsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.ListSuiteDefinitions(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_opListSuiteDefinitions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotdeviceadvisor",
OperationName: "ListSuiteDefinitions",
}
}
| 217 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdeviceadvisor
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/iotdeviceadvisor/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists runs of the specified Device Advisor test suite. You can list all runs of
// the test suite, or the runs of a specific version of the test suite. Requires
// permission to access the ListSuiteRuns (https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-actions-as-permissions)
// action.
func (c *Client) ListSuiteRuns(ctx context.Context, params *ListSuiteRunsInput, optFns ...func(*Options)) (*ListSuiteRunsOutput, error) {
if params == nil {
params = &ListSuiteRunsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListSuiteRuns", params, optFns, c.addOperationListSuiteRunsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListSuiteRunsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListSuiteRunsInput struct {
// The maximum number of results to return at once.
MaxResults int32
// A token to retrieve the next set of results.
NextToken *string
// Lists the test suite runs of the specified test suite based on suite definition
// ID.
SuiteDefinitionId *string
// Must be passed along with suiteDefinitionId . Lists the test suite runs of the
// specified test suite based on suite definition version.
SuiteDefinitionVersion *string
noSmithyDocumentSerde
}
type ListSuiteRunsOutput struct {
// A token to retrieve the next set of results.
NextToken *string
// An array of objects that provide summaries of information about the suite runs
// in the list.
SuiteRunsList []types.SuiteRunInformation
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListSuiteRunsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListSuiteRuns{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListSuiteRuns{}, 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_opListSuiteRuns(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
}
// ListSuiteRunsAPIClient is a client that implements the ListSuiteRuns operation.
type ListSuiteRunsAPIClient interface {
ListSuiteRuns(context.Context, *ListSuiteRunsInput, ...func(*Options)) (*ListSuiteRunsOutput, error)
}
var _ ListSuiteRunsAPIClient = (*Client)(nil)
// ListSuiteRunsPaginatorOptions is the paginator options for ListSuiteRuns
type ListSuiteRunsPaginatorOptions struct {
// The maximum number of results to return at once.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListSuiteRunsPaginator is a paginator for ListSuiteRuns
type ListSuiteRunsPaginator struct {
options ListSuiteRunsPaginatorOptions
client ListSuiteRunsAPIClient
params *ListSuiteRunsInput
nextToken *string
firstPage bool
}
// NewListSuiteRunsPaginator returns a new ListSuiteRunsPaginator
func NewListSuiteRunsPaginator(client ListSuiteRunsAPIClient, params *ListSuiteRunsInput, optFns ...func(*ListSuiteRunsPaginatorOptions)) *ListSuiteRunsPaginator {
if params == nil {
params = &ListSuiteRunsInput{}
}
options := ListSuiteRunsPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListSuiteRunsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListSuiteRunsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListSuiteRuns page.
func (p *ListSuiteRunsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListSuiteRunsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
params.MaxResults = p.options.Limit
result, err := p.client.ListSuiteRuns(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_opListSuiteRuns(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotdeviceadvisor",
OperationName: "ListSuiteRuns",
}
}
| 224 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdeviceadvisor
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 an IoT Device Advisor resource. Requires permission
// to access the ListTagsForResource (https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-actions-as-permissions)
// action.
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 resource ARN of the IoT Device Advisor resource. This can be
// SuiteDefinition ARN or SuiteRun ARN.
//
// This member is required.
ResourceArn *string
noSmithyDocumentSerde
}
type ListTagsForResourceOutput struct {
// The tags attached to the IoT Device Advisor resource.
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: "iotdeviceadvisor",
OperationName: "ListTagsForResource",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdeviceadvisor
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/iotdeviceadvisor/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Starts a Device Advisor test suite run. Requires permission to access the
// StartSuiteRun (https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-actions-as-permissions)
// action.
func (c *Client) StartSuiteRun(ctx context.Context, params *StartSuiteRunInput, optFns ...func(*Options)) (*StartSuiteRunOutput, error) {
if params == nil {
params = &StartSuiteRunInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartSuiteRun", params, optFns, c.addOperationStartSuiteRunMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartSuiteRunOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartSuiteRunInput struct {
// Suite definition ID of the test suite.
//
// This member is required.
SuiteDefinitionId *string
// Suite run configuration.
//
// This member is required.
SuiteRunConfiguration *types.SuiteRunConfiguration
// Suite definition version of the test suite.
SuiteDefinitionVersion *string
// The tags to be attached to the suite run.
Tags map[string]string
noSmithyDocumentSerde
}
type StartSuiteRunOutput struct {
// Starts a Device Advisor test suite run based on suite create time.
CreatedAt *time.Time
// The response of an Device Advisor test endpoint.
Endpoint *string
// Amazon Resource Name (ARN) of the started suite run.
SuiteRunArn *string
// Suite Run ID of the started suite run.
SuiteRunId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartSuiteRunMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartSuiteRun{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartSuiteRun{}, 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 = addOpStartSuiteRunValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartSuiteRun(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_opStartSuiteRun(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotdeviceadvisor",
OperationName: "StartSuiteRun",
}
}
| 148 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdeviceadvisor
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 a Device Advisor test suite run that is currently running. Requires
// permission to access the StopSuiteRun (https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-actions-as-permissions)
// action.
func (c *Client) StopSuiteRun(ctx context.Context, params *StopSuiteRunInput, optFns ...func(*Options)) (*StopSuiteRunOutput, error) {
if params == nil {
params = &StopSuiteRunInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StopSuiteRun", params, optFns, c.addOperationStopSuiteRunMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StopSuiteRunOutput)
out.ResultMetadata = metadata
return out, nil
}
type StopSuiteRunInput struct {
// Suite definition ID of the test suite run to be stopped.
//
// This member is required.
SuiteDefinitionId *string
// Suite run ID of the test suite run to be stopped.
//
// This member is required.
SuiteRunId *string
noSmithyDocumentSerde
}
type StopSuiteRunOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStopSuiteRunMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStopSuiteRun{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStopSuiteRun{}, 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 = addOpStopSuiteRunValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStopSuiteRun(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_opStopSuiteRun(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotdeviceadvisor",
OperationName: "StopSuiteRun",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdeviceadvisor
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"
)
// Adds to and modifies existing tags of an IoT Device Advisor resource. Requires
// permission to access the TagResource (https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-actions-as-permissions)
// action.
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 resource ARN of an IoT Device Advisor resource. This can be SuiteDefinition
// ARN or SuiteRun ARN.
//
// This member is required.
ResourceArn *string
// The tags to be attached to the IoT Device Advisor resource.
//
// 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: "iotdeviceadvisor",
OperationName: "TagResource",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdeviceadvisor
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"
)
// Removes tags from an IoT Device Advisor resource. Requires permission to access
// the UntagResource (https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-actions-as-permissions)
// action.
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 resource ARN of an IoT Device Advisor resource. This can be SuiteDefinition
// ARN or SuiteRun ARN.
//
// This member is required.
ResourceArn *string
// List of tag keys to remove from the IoT Device Advisor resource.
//
// 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: "iotdeviceadvisor",
OperationName: "UntagResource",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdeviceadvisor
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/iotdeviceadvisor/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Updates a Device Advisor test suite. Requires permission to access the
// UpdateSuiteDefinition (https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-actions-as-permissions)
// action.
func (c *Client) UpdateSuiteDefinition(ctx context.Context, params *UpdateSuiteDefinitionInput, optFns ...func(*Options)) (*UpdateSuiteDefinitionOutput, error) {
if params == nil {
params = &UpdateSuiteDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateSuiteDefinition", params, optFns, c.addOperationUpdateSuiteDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateSuiteDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateSuiteDefinitionInput struct {
// Updates a Device Advisor test suite with suite definition configuration.
//
// This member is required.
SuiteDefinitionConfiguration *types.SuiteDefinitionConfiguration
// Suite definition ID of the test suite to be updated.
//
// This member is required.
SuiteDefinitionId *string
noSmithyDocumentSerde
}
type UpdateSuiteDefinitionOutput struct {
// Timestamp of when the test suite was created.
CreatedAt *time.Time
// Timestamp of when the test suite was updated.
LastUpdatedAt *time.Time
// Amazon Resource Name (ARN) of the updated test suite.
SuiteDefinitionArn *string
// Suite definition ID of the updated test suite.
SuiteDefinitionId *string
// Updates the suite definition name. This is a required parameter.
SuiteDefinitionName *string
// Suite definition version of the updated test suite.
SuiteDefinitionVersion *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateSuiteDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateSuiteDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateSuiteDefinition{}, 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 = addOpUpdateSuiteDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateSuiteDefinition(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_opUpdateSuiteDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotdeviceadvisor",
OperationName: "UpdateSuiteDefinition",
}
}
| 148 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdeviceadvisor
import (
"bytes"
"context"
"encoding/json"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
"github.com/aws/aws-sdk-go-v2/service/iotdeviceadvisor/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"
"strings"
)
type awsRestjson1_deserializeOpCreateSuiteDefinition struct {
}
func (*awsRestjson1_deserializeOpCreateSuiteDefinition) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpCreateSuiteDefinition) 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_deserializeOpErrorCreateSuiteDefinition(response, &metadata)
}
output := &CreateSuiteDefinitionOutput{}
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_deserializeOpDocumentCreateSuiteDefinitionOutput(&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_deserializeOpErrorCreateSuiteDefinition(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("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentCreateSuiteDefinitionOutput(v **CreateSuiteDefinitionOutput, 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 *CreateSuiteDefinitionOutput
if *v == nil {
sv = &CreateSuiteDefinitionOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "createdAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "suiteDefinitionArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value)
}
sv.SuiteDefinitionArn = ptr.String(jtv)
}
case "suiteDefinitionId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UUID to be of type string, got %T instead", value)
}
sv.SuiteDefinitionId = ptr.String(jtv)
}
case "suiteDefinitionName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SuiteDefinitionName to be of type string, got %T instead", value)
}
sv.SuiteDefinitionName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDeleteSuiteDefinition struct {
}
func (*awsRestjson1_deserializeOpDeleteSuiteDefinition) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeleteSuiteDefinition) 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_deserializeOpErrorDeleteSuiteDefinition(response, &metadata)
}
output := &DeleteSuiteDefinitionOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDeleteSuiteDefinition(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("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpGetEndpoint struct {
}
func (*awsRestjson1_deserializeOpGetEndpoint) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetEndpoint) 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_deserializeOpErrorGetEndpoint(response, &metadata)
}
output := &GetEndpointOutput{}
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_deserializeOpDocumentGetEndpointOutput(&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_deserializeOpErrorGetEndpoint(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("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetEndpointOutput(v **GetEndpointOutput, 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 *GetEndpointOutput
if *v == nil {
sv = &GetEndpointOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "endpoint":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Endpoint to be of type string, got %T instead", value)
}
sv.Endpoint = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetSuiteDefinition struct {
}
func (*awsRestjson1_deserializeOpGetSuiteDefinition) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetSuiteDefinition) 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_deserializeOpErrorGetSuiteDefinition(response, &metadata)
}
output := &GetSuiteDefinitionOutput{}
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_deserializeOpDocumentGetSuiteDefinitionOutput(&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_deserializeOpErrorGetSuiteDefinition(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("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetSuiteDefinitionOutput(v **GetSuiteDefinitionOutput, 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 *GetSuiteDefinitionOutput
if *v == nil {
sv = &GetSuiteDefinitionOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "createdAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "lastModifiedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "latestVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SuiteDefinitionVersion to be of type string, got %T instead", value)
}
sv.LatestVersion = ptr.String(jtv)
}
case "suiteDefinitionArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value)
}
sv.SuiteDefinitionArn = ptr.String(jtv)
}
case "suiteDefinitionConfiguration":
if err := awsRestjson1_deserializeDocumentSuiteDefinitionConfiguration(&sv.SuiteDefinitionConfiguration, value); err != nil {
return err
}
case "suiteDefinitionId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UUID to be of type string, got %T instead", value)
}
sv.SuiteDefinitionId = ptr.String(jtv)
}
case "suiteDefinitionVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SuiteDefinitionVersion to be of type string, got %T instead", value)
}
sv.SuiteDefinitionVersion = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetSuiteRun struct {
}
func (*awsRestjson1_deserializeOpGetSuiteRun) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetSuiteRun) 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_deserializeOpErrorGetSuiteRun(response, &metadata)
}
output := &GetSuiteRunOutput{}
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_deserializeOpDocumentGetSuiteRunOutput(&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_deserializeOpErrorGetSuiteRun(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("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetSuiteRunOutput(v **GetSuiteRunOutput, 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 *GetSuiteRunOutput
if *v == nil {
sv = &GetSuiteRunOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "endTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.EndTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "errorReason":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorReason to be of type string, got %T instead", value)
}
sv.ErrorReason = ptr.String(jtv)
}
case "startTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SuiteRunStatus to be of type string, got %T instead", value)
}
sv.Status = types.SuiteRunStatus(jtv)
}
case "suiteDefinitionId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UUID to be of type string, got %T instead", value)
}
sv.SuiteDefinitionId = ptr.String(jtv)
}
case "suiteDefinitionVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SuiteDefinitionVersion to be of type string, got %T instead", value)
}
sv.SuiteDefinitionVersion = ptr.String(jtv)
}
case "suiteRunArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value)
}
sv.SuiteRunArn = ptr.String(jtv)
}
case "suiteRunConfiguration":
if err := awsRestjson1_deserializeDocumentSuiteRunConfiguration(&sv.SuiteRunConfiguration, value); err != nil {
return err
}
case "suiteRunId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UUID to be of type string, got %T instead", value)
}
sv.SuiteRunId = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil {
return err
}
case "testResult":
if err := awsRestjson1_deserializeDocumentTestResult(&sv.TestResult, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetSuiteRunReport struct {
}
func (*awsRestjson1_deserializeOpGetSuiteRunReport) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetSuiteRunReport) 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_deserializeOpErrorGetSuiteRunReport(response, &metadata)
}
output := &GetSuiteRunReportOutput{}
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_deserializeOpDocumentGetSuiteRunReportOutput(&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_deserializeOpErrorGetSuiteRunReport(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("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetSuiteRunReportOutput(v **GetSuiteRunReportOutput, 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 *GetSuiteRunReportOutput
if *v == nil {
sv = &GetSuiteRunReportOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "qualificationReportDownloadUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected QualificationReportDownloadUrl to be of type string, got %T instead", value)
}
sv.QualificationReportDownloadUrl = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListSuiteDefinitions struct {
}
func (*awsRestjson1_deserializeOpListSuiteDefinitions) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListSuiteDefinitions) 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_deserializeOpErrorListSuiteDefinitions(response, &metadata)
}
output := &ListSuiteDefinitionsOutput{}
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_deserializeOpDocumentListSuiteDefinitionsOutput(&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_deserializeOpErrorListSuiteDefinitions(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("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListSuiteDefinitionsOutput(v **ListSuiteDefinitionsOutput, 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 *ListSuiteDefinitionsOutput
if *v == nil {
sv = &ListSuiteDefinitionsOutput{}
} 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 Token to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "suiteDefinitionInformationList":
if err := awsRestjson1_deserializeDocumentSuiteDefinitionInformationList(&sv.SuiteDefinitionInformationList, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListSuiteRuns struct {
}
func (*awsRestjson1_deserializeOpListSuiteRuns) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListSuiteRuns) 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_deserializeOpErrorListSuiteRuns(response, &metadata)
}
output := &ListSuiteRunsOutput{}
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_deserializeOpDocumentListSuiteRunsOutput(&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_deserializeOpErrorListSuiteRuns(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("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListSuiteRunsOutput(v **ListSuiteRunsOutput, 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 *ListSuiteRunsOutput
if *v == nil {
sv = &ListSuiteRunsOutput{}
} 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 Token to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "suiteRunsList":
if err := awsRestjson1_deserializeDocumentSuiteRunsList(&sv.SuiteRunsList, 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("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(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_deserializeDocumentTagMap(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpStartSuiteRun struct {
}
func (*awsRestjson1_deserializeOpStartSuiteRun) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpStartSuiteRun) 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_deserializeOpErrorStartSuiteRun(response, &metadata)
}
output := &StartSuiteRunOutput{}
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_deserializeOpDocumentStartSuiteRunOutput(&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_deserializeOpErrorStartSuiteRun(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("ConflictException", errorCode):
return awsRestjson1_deserializeErrorConflictException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentStartSuiteRunOutput(v **StartSuiteRunOutput, 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 *StartSuiteRunOutput
if *v == nil {
sv = &StartSuiteRunOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "createdAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "endpoint":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Endpoint to be of type string, got %T instead", value)
}
sv.Endpoint = ptr.String(jtv)
}
case "suiteRunArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value)
}
sv.SuiteRunArn = ptr.String(jtv)
}
case "suiteRunId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UUID to be of type string, got %T instead", value)
}
sv.SuiteRunId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpStopSuiteRun struct {
}
func (*awsRestjson1_deserializeOpStopSuiteRun) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpStopSuiteRun) 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_deserializeOpErrorStopSuiteRun(response, &metadata)
}
output := &StopSuiteRunOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorStopSuiteRun(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("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(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("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(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("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpUpdateSuiteDefinition struct {
}
func (*awsRestjson1_deserializeOpUpdateSuiteDefinition) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateSuiteDefinition) 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_deserializeOpErrorUpdateSuiteDefinition(response, &metadata)
}
output := &UpdateSuiteDefinitionOutput{}
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_deserializeOpDocumentUpdateSuiteDefinitionOutput(&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_deserializeOpErrorUpdateSuiteDefinition(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("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentUpdateSuiteDefinitionOutput(v **UpdateSuiteDefinitionOutput, 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 *UpdateSuiteDefinitionOutput
if *v == nil {
sv = &UpdateSuiteDefinitionOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "createdAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "lastUpdatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "suiteDefinitionArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value)
}
sv.SuiteDefinitionArn = ptr.String(jtv)
}
case "suiteDefinitionId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UUID to be of type string, got %T instead", value)
}
sv.SuiteDefinitionId = ptr.String(jtv)
}
case "suiteDefinitionName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SuiteDefinitionName to be of type string, got %T instead", value)
}
sv.SuiteDefinitionName = ptr.String(jtv)
}
case "suiteDefinitionVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SuiteDefinitionVersion to be of type string, got %T instead", value)
}
sv.SuiteDefinitionVersion = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
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_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_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 Message to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDeviceUnderTest(v **types.DeviceUnderTest, 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.DeviceUnderTest
if *v == nil {
sv = &types.DeviceUnderTest{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "certificateArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value)
}
sv.CertificateArn = ptr.String(jtv)
}
case "deviceRoleArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value)
}
sv.DeviceRoleArn = ptr.String(jtv)
}
case "thingArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value)
}
sv.ThingArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDeviceUnderTestList(v *[]types.DeviceUnderTest, 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.DeviceUnderTest
if *v == nil {
cv = []types.DeviceUnderTest{}
} else {
cv = *v
}
for _, value := range shape {
var col types.DeviceUnderTest
destAddr := &col
if err := awsRestjson1_deserializeDocumentDeviceUnderTest(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentGroupResult(v **types.GroupResult, 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.GroupResult
if *v == nil {
sv = &types.GroupResult{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "groupId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UUID to be of type string, got %T instead", value)
}
sv.GroupId = ptr.String(jtv)
}
case "groupName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected GroupName to be of type string, got %T instead", value)
}
sv.GroupName = ptr.String(jtv)
}
case "tests":
if err := awsRestjson1_deserializeDocumentTestCaseRuns(&sv.Tests, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentGroupResultList(v *[]types.GroupResult, 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.GroupResult
if *v == nil {
cv = []types.GroupResult{}
} else {
cv = *v
}
for _, value := range shape {
var col types.GroupResult
destAddr := &col
if err := awsRestjson1_deserializeDocumentGroupResult(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
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 Message to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
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 Message to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSelectedTestList(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 UUID to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentSuiteDefinitionConfiguration(v **types.SuiteDefinitionConfiguration, 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.SuiteDefinitionConfiguration
if *v == nil {
sv = &types.SuiteDefinitionConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "devicePermissionRoleArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value)
}
sv.DevicePermissionRoleArn = ptr.String(jtv)
}
case "devices":
if err := awsRestjson1_deserializeDocumentDeviceUnderTestList(&sv.Devices, value); err != nil {
return err
}
case "intendedForQualification":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected IntendedForQualificationBoolean to be of type *bool, got %T instead", value)
}
sv.IntendedForQualification = jtv
}
case "isLongDurationTest":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected IsLongDurationTestBoolean to be of type *bool, got %T instead", value)
}
sv.IsLongDurationTest = jtv
}
case "protocol":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Protocol to be of type string, got %T instead", value)
}
sv.Protocol = types.Protocol(jtv)
}
case "rootGroup":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected RootGroup to be of type string, got %T instead", value)
}
sv.RootGroup = ptr.String(jtv)
}
case "suiteDefinitionName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SuiteDefinitionName to be of type string, got %T instead", value)
}
sv.SuiteDefinitionName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSuiteDefinitionInformation(v **types.SuiteDefinitionInformation, 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.SuiteDefinitionInformation
if *v == nil {
sv = &types.SuiteDefinitionInformation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "createdAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "defaultDevices":
if err := awsRestjson1_deserializeDocumentDeviceUnderTestList(&sv.DefaultDevices, value); err != nil {
return err
}
case "intendedForQualification":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected IntendedForQualificationBoolean to be of type *bool, got %T instead", value)
}
sv.IntendedForQualification = jtv
}
case "isLongDurationTest":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected IsLongDurationTestBoolean to be of type *bool, got %T instead", value)
}
sv.IsLongDurationTest = jtv
}
case "protocol":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Protocol to be of type string, got %T instead", value)
}
sv.Protocol = types.Protocol(jtv)
}
case "suiteDefinitionId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UUID to be of type string, got %T instead", value)
}
sv.SuiteDefinitionId = ptr.String(jtv)
}
case "suiteDefinitionName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SuiteDefinitionName to be of type string, got %T instead", value)
}
sv.SuiteDefinitionName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSuiteDefinitionInformationList(v *[]types.SuiteDefinitionInformation, 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.SuiteDefinitionInformation
if *v == nil {
cv = []types.SuiteDefinitionInformation{}
} else {
cv = *v
}
for _, value := range shape {
var col types.SuiteDefinitionInformation
destAddr := &col
if err := awsRestjson1_deserializeDocumentSuiteDefinitionInformation(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentSuiteRunConfiguration(v **types.SuiteRunConfiguration, 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.SuiteRunConfiguration
if *v == nil {
sv = &types.SuiteRunConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "parallelRun":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected ParallelRun to be of type *bool, got %T instead", value)
}
sv.ParallelRun = jtv
}
case "primaryDevice":
if err := awsRestjson1_deserializeDocumentDeviceUnderTest(&sv.PrimaryDevice, value); err != nil {
return err
}
case "selectedTestList":
if err := awsRestjson1_deserializeDocumentSelectedTestList(&sv.SelectedTestList, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSuiteRunInformation(v **types.SuiteRunInformation, 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.SuiteRunInformation
if *v == nil {
sv = &types.SuiteRunInformation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "createdAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "endAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.EndAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "failed":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected SuiteRunResultCount to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Failed = int32(i64)
}
case "passed":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected SuiteRunResultCount to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Passed = int32(i64)
}
case "startedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.StartedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SuiteRunStatus to be of type string, got %T instead", value)
}
sv.Status = types.SuiteRunStatus(jtv)
}
case "suiteDefinitionId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UUID to be of type string, got %T instead", value)
}
sv.SuiteDefinitionId = ptr.String(jtv)
}
case "suiteDefinitionName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SuiteDefinitionName to be of type string, got %T instead", value)
}
sv.SuiteDefinitionName = ptr.String(jtv)
}
case "suiteDefinitionVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SuiteDefinitionVersion to be of type string, got %T instead", value)
}
sv.SuiteDefinitionVersion = ptr.String(jtv)
}
case "suiteRunId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UUID to be of type string, got %T instead", value)
}
sv.SuiteRunId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSuiteRunsList(v *[]types.SuiteRunInformation, 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.SuiteRunInformation
if *v == nil {
cv = []types.SuiteRunInformation{}
} else {
cv = *v
}
for _, value := range shape {
var col types.SuiteRunInformation
destAddr := &col
if err := awsRestjson1_deserializeDocumentSuiteRunInformation(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentTagMap(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 String256 to be of type string, got %T instead", value)
}
parsedVal = jtv
}
mv[key] = parsedVal
}
*v = mv
return nil
}
func awsRestjson1_deserializeDocumentTestCaseRun(v **types.TestCaseRun, 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.TestCaseRun
if *v == nil {
sv = &types.TestCaseRun{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "endTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.EndTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "failure":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Failure to be of type string, got %T instead", value)
}
sv.Failure = ptr.String(jtv)
}
case "logUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LogUrl to be of type string, got %T instead", value)
}
sv.LogUrl = ptr.String(jtv)
}
case "startTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Status to be of type string, got %T instead", value)
}
sv.Status = types.Status(jtv)
}
case "testCaseDefinitionId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UUID to be of type string, got %T instead", value)
}
sv.TestCaseDefinitionId = ptr.String(jtv)
}
case "testCaseDefinitionName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TestCaseDefinitionName to be of type string, got %T instead", value)
}
sv.TestCaseDefinitionName = ptr.String(jtv)
}
case "testCaseRunId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UUID to be of type string, got %T instead", value)
}
sv.TestCaseRunId = ptr.String(jtv)
}
case "testScenarios":
if err := awsRestjson1_deserializeDocumentTestCaseScenariosList(&sv.TestScenarios, value); err != nil {
return err
}
case "warnings":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Warnings to be of type string, got %T instead", value)
}
sv.Warnings = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTestCaseRuns(v *[]types.TestCaseRun, 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.TestCaseRun
if *v == nil {
cv = []types.TestCaseRun{}
} else {
cv = *v
}
for _, value := range shape {
var col types.TestCaseRun
destAddr := &col
if err := awsRestjson1_deserializeDocumentTestCaseRun(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentTestCaseScenario(v **types.TestCaseScenario, 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.TestCaseScenario
if *v == nil {
sv = &types.TestCaseScenario{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "failure":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Failure to be of type string, got %T instead", value)
}
sv.Failure = ptr.String(jtv)
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TestCaseScenarioStatus to be of type string, got %T instead", value)
}
sv.Status = types.TestCaseScenarioStatus(jtv)
}
case "systemMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SystemMessage to be of type string, got %T instead", value)
}
sv.SystemMessage = ptr.String(jtv)
}
case "testCaseScenarioId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TestCaseScenarioId to be of type string, got %T instead", value)
}
sv.TestCaseScenarioId = ptr.String(jtv)
}
case "testCaseScenarioType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TestCaseScenarioType to be of type string, got %T instead", value)
}
sv.TestCaseScenarioType = types.TestCaseScenarioType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTestCaseScenariosList(v *[]types.TestCaseScenario, 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.TestCaseScenario
if *v == nil {
cv = []types.TestCaseScenario{}
} else {
cv = *v
}
for _, value := range shape {
var col types.TestCaseScenario
destAddr := &col
if err := awsRestjson1_deserializeDocumentTestCaseScenario(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentTestResult(v **types.TestResult, 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.TestResult
if *v == nil {
sv = &types.TestResult{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "groups":
if err := awsRestjson1_deserializeDocumentGroupResultList(&sv.Groups, value); err != nil {
return err
}
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 Message to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
| 3,548 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package iotdeviceadvisor provides the API client, operations, and parameter
// types for AWS IoT Core Device Advisor.
//
// Amazon Web Services IoT Core Device Advisor is a cloud-based, fully managed
// test capability for validating IoT devices during device software development.
// Device Advisor provides pre-built tests that you can use to validate IoT devices
// for reliable and secure connectivity with Amazon Web Services IoT Core before
// deploying devices to production. By using Device Advisor, you can confirm that
// your devices can connect to Amazon Web Services IoT Core, follow security best
// practices and, if applicable, receive software updates from IoT Device
// Management. You can also download signed qualification reports to submit to the
// Amazon Web Services Partner Network to get your device qualified for the Amazon
// Web Services Partner Device Catalog without the need to send your device in and
// wait for it to be tested.
package iotdeviceadvisor
| 18 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdeviceadvisor
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/iotdeviceadvisor/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 = "iotdeviceadvisor"
}
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 iotdeviceadvisor
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.19.2"
| 7 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdeviceadvisor
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdeviceadvisor
import (
"bytes"
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/iotdeviceadvisor/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_serializeOpCreateSuiteDefinition struct {
}
func (*awsRestjson1_serializeOpCreateSuiteDefinition) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateSuiteDefinition) 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.(*CreateSuiteDefinitionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/suiteDefinitions")
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_serializeOpDocumentCreateSuiteDefinitionInput(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_serializeOpHttpBindingsCreateSuiteDefinitionInput(v *CreateSuiteDefinitionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateSuiteDefinitionInput(v *CreateSuiteDefinitionInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.SuiteDefinitionConfiguration != nil {
ok := object.Key("suiteDefinitionConfiguration")
if err := awsRestjson1_serializeDocumentSuiteDefinitionConfiguration(v.SuiteDefinitionConfiguration, ok); err != nil {
return err
}
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteSuiteDefinition struct {
}
func (*awsRestjson1_serializeOpDeleteSuiteDefinition) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteSuiteDefinition) 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.(*DeleteSuiteDefinitionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/suiteDefinitions/{suiteDefinitionId}")
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_serializeOpHttpBindingsDeleteSuiteDefinitionInput(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_serializeOpHttpBindingsDeleteSuiteDefinitionInput(v *DeleteSuiteDefinitionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SuiteDefinitionId == nil || len(*v.SuiteDefinitionId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member suiteDefinitionId must not be empty")}
}
if v.SuiteDefinitionId != nil {
if err := encoder.SetURI("suiteDefinitionId").String(*v.SuiteDefinitionId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetEndpoint struct {
}
func (*awsRestjson1_serializeOpGetEndpoint) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetEndpoint) 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.(*GetEndpointInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/endpoint")
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_serializeOpHttpBindingsGetEndpointInput(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_serializeOpHttpBindingsGetEndpointInput(v *GetEndpointInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if len(v.AuthenticationMethod) > 0 {
encoder.SetQuery("authenticationMethod").String(string(v.AuthenticationMethod))
}
if v.CertificateArn != nil {
encoder.SetQuery("certificateArn").String(*v.CertificateArn)
}
if v.DeviceRoleArn != nil {
encoder.SetQuery("deviceRoleArn").String(*v.DeviceRoleArn)
}
if v.ThingArn != nil {
encoder.SetQuery("thingArn").String(*v.ThingArn)
}
return nil
}
type awsRestjson1_serializeOpGetSuiteDefinition struct {
}
func (*awsRestjson1_serializeOpGetSuiteDefinition) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetSuiteDefinition) 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.(*GetSuiteDefinitionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/suiteDefinitions/{suiteDefinitionId}")
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_serializeOpHttpBindingsGetSuiteDefinitionInput(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_serializeOpHttpBindingsGetSuiteDefinitionInput(v *GetSuiteDefinitionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SuiteDefinitionId == nil || len(*v.SuiteDefinitionId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member suiteDefinitionId must not be empty")}
}
if v.SuiteDefinitionId != nil {
if err := encoder.SetURI("suiteDefinitionId").String(*v.SuiteDefinitionId); err != nil {
return err
}
}
if v.SuiteDefinitionVersion != nil {
encoder.SetQuery("suiteDefinitionVersion").String(*v.SuiteDefinitionVersion)
}
return nil
}
type awsRestjson1_serializeOpGetSuiteRun struct {
}
func (*awsRestjson1_serializeOpGetSuiteRun) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetSuiteRun) 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.(*GetSuiteRunInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/suiteDefinitions/{suiteDefinitionId}/suiteRuns/{suiteRunId}")
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_serializeOpHttpBindingsGetSuiteRunInput(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_serializeOpHttpBindingsGetSuiteRunInput(v *GetSuiteRunInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SuiteDefinitionId == nil || len(*v.SuiteDefinitionId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member suiteDefinitionId must not be empty")}
}
if v.SuiteDefinitionId != nil {
if err := encoder.SetURI("suiteDefinitionId").String(*v.SuiteDefinitionId); err != nil {
return err
}
}
if v.SuiteRunId == nil || len(*v.SuiteRunId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member suiteRunId must not be empty")}
}
if v.SuiteRunId != nil {
if err := encoder.SetURI("suiteRunId").String(*v.SuiteRunId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetSuiteRunReport struct {
}
func (*awsRestjson1_serializeOpGetSuiteRunReport) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetSuiteRunReport) 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.(*GetSuiteRunReportInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/suiteDefinitions/{suiteDefinitionId}/suiteRuns/{suiteRunId}/report")
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_serializeOpHttpBindingsGetSuiteRunReportInput(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_serializeOpHttpBindingsGetSuiteRunReportInput(v *GetSuiteRunReportInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SuiteDefinitionId == nil || len(*v.SuiteDefinitionId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member suiteDefinitionId must not be empty")}
}
if v.SuiteDefinitionId != nil {
if err := encoder.SetURI("suiteDefinitionId").String(*v.SuiteDefinitionId); err != nil {
return err
}
}
if v.SuiteRunId == nil || len(*v.SuiteRunId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member suiteRunId must not be empty")}
}
if v.SuiteRunId != nil {
if err := encoder.SetURI("suiteRunId").String(*v.SuiteRunId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListSuiteDefinitions struct {
}
func (*awsRestjson1_serializeOpListSuiteDefinitions) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListSuiteDefinitions) 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.(*ListSuiteDefinitionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/suiteDefinitions")
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_serializeOpHttpBindingsListSuiteDefinitionsInput(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_serializeOpHttpBindingsListSuiteDefinitionsInput(v *ListSuiteDefinitionsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListSuiteRuns struct {
}
func (*awsRestjson1_serializeOpListSuiteRuns) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListSuiteRuns) 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.(*ListSuiteRunsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/suiteRuns")
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_serializeOpHttpBindingsListSuiteRunsInput(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_serializeOpHttpBindingsListSuiteRunsInput(v *ListSuiteRunsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.SuiteDefinitionId != nil {
encoder.SetQuery("suiteDefinitionId").String(*v.SuiteDefinitionId)
}
if v.SuiteDefinitionVersion != nil {
encoder.SetQuery("suiteDefinitionVersion").String(*v.SuiteDefinitionVersion)
}
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_serializeOpStartSuiteRun struct {
}
func (*awsRestjson1_serializeOpStartSuiteRun) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartSuiteRun) 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.(*StartSuiteRunInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/suiteDefinitions/{suiteDefinitionId}/suiteRuns")
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_serializeOpHttpBindingsStartSuiteRunInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentStartSuiteRunInput(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_serializeOpHttpBindingsStartSuiteRunInput(v *StartSuiteRunInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SuiteDefinitionId == nil || len(*v.SuiteDefinitionId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member suiteDefinitionId must not be empty")}
}
if v.SuiteDefinitionId != nil {
if err := encoder.SetURI("suiteDefinitionId").String(*v.SuiteDefinitionId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentStartSuiteRunInput(v *StartSuiteRunInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.SuiteDefinitionVersion != nil {
ok := object.Key("suiteDefinitionVersion")
ok.String(*v.SuiteDefinitionVersion)
}
if v.SuiteRunConfiguration != nil {
ok := object.Key("suiteRunConfiguration")
if err := awsRestjson1_serializeDocumentSuiteRunConfiguration(v.SuiteRunConfiguration, ok); err != nil {
return err
}
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpStopSuiteRun struct {
}
func (*awsRestjson1_serializeOpStopSuiteRun) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStopSuiteRun) 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.(*StopSuiteRunInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/suiteDefinitions/{suiteDefinitionId}/suiteRuns/{suiteRunId}/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}
}
if err := awsRestjson1_serializeOpHttpBindingsStopSuiteRunInput(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_serializeOpHttpBindingsStopSuiteRunInput(v *StopSuiteRunInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SuiteDefinitionId == nil || len(*v.SuiteDefinitionId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member suiteDefinitionId must not be empty")}
}
if v.SuiteDefinitionId != nil {
if err := encoder.SetURI("suiteDefinitionId").String(*v.SuiteDefinitionId); err != nil {
return err
}
}
if v.SuiteRunId == nil || len(*v.SuiteRunId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member suiteRunId must not be empty")}
}
if v.SuiteRunId != nil {
if err := encoder.SetURI("suiteRunId").String(*v.SuiteRunId); err != nil {
return err
}
}
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 = "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_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_serializeDocumentTagMap(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
}
type awsRestjson1_serializeOpUpdateSuiteDefinition struct {
}
func (*awsRestjson1_serializeOpUpdateSuiteDefinition) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateSuiteDefinition) 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.(*UpdateSuiteDefinitionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/suiteDefinitions/{suiteDefinitionId}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "PATCH"
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_serializeOpHttpBindingsUpdateSuiteDefinitionInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateSuiteDefinitionInput(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_serializeOpHttpBindingsUpdateSuiteDefinitionInput(v *UpdateSuiteDefinitionInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SuiteDefinitionId == nil || len(*v.SuiteDefinitionId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member suiteDefinitionId must not be empty")}
}
if v.SuiteDefinitionId != nil {
if err := encoder.SetURI("suiteDefinitionId").String(*v.SuiteDefinitionId); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateSuiteDefinitionInput(v *UpdateSuiteDefinitionInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.SuiteDefinitionConfiguration != nil {
ok := object.Key("suiteDefinitionConfiguration")
if err := awsRestjson1_serializeDocumentSuiteDefinitionConfiguration(v.SuiteDefinitionConfiguration, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentDeviceUnderTest(v *types.DeviceUnderTest, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CertificateArn != nil {
ok := object.Key("certificateArn")
ok.String(*v.CertificateArn)
}
if v.DeviceRoleArn != nil {
ok := object.Key("deviceRoleArn")
ok.String(*v.DeviceRoleArn)
}
if v.ThingArn != nil {
ok := object.Key("thingArn")
ok.String(*v.ThingArn)
}
return nil
}
func awsRestjson1_serializeDocumentDeviceUnderTestList(v []types.DeviceUnderTest, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentDeviceUnderTest(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentSelectedTestList(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_serializeDocumentSuiteDefinitionConfiguration(v *types.SuiteDefinitionConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DevicePermissionRoleArn != nil {
ok := object.Key("devicePermissionRoleArn")
ok.String(*v.DevicePermissionRoleArn)
}
if v.Devices != nil {
ok := object.Key("devices")
if err := awsRestjson1_serializeDocumentDeviceUnderTestList(v.Devices, ok); err != nil {
return err
}
}
if v.IntendedForQualification {
ok := object.Key("intendedForQualification")
ok.Boolean(v.IntendedForQualification)
}
if v.IsLongDurationTest {
ok := object.Key("isLongDurationTest")
ok.Boolean(v.IsLongDurationTest)
}
if len(v.Protocol) > 0 {
ok := object.Key("protocol")
ok.String(string(v.Protocol))
}
if v.RootGroup != nil {
ok := object.Key("rootGroup")
ok.String(*v.RootGroup)
}
if v.SuiteDefinitionName != nil {
ok := object.Key("suiteDefinitionName")
ok.String(*v.SuiteDefinitionName)
}
return nil
}
func awsRestjson1_serializeDocumentSuiteRunConfiguration(v *types.SuiteRunConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ParallelRun {
ok := object.Key("parallelRun")
ok.Boolean(v.ParallelRun)
}
if v.PrimaryDevice != nil {
ok := object.Key("primaryDevice")
if err := awsRestjson1_serializeDocumentDeviceUnderTest(v.PrimaryDevice, ok); err != nil {
return err
}
}
if v.SelectedTestList != nil {
ok := object.Key("selectedTestList")
if err := awsRestjson1_serializeDocumentSelectedTestList(v.SelectedTestList, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentTagMap(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
}
| 1,111 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotdeviceadvisor
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/iotdeviceadvisor/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpCreateSuiteDefinition struct {
}
func (*validateOpCreateSuiteDefinition) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateSuiteDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateSuiteDefinitionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateSuiteDefinitionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteSuiteDefinition struct {
}
func (*validateOpDeleteSuiteDefinition) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteSuiteDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteSuiteDefinitionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteSuiteDefinitionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetSuiteDefinition struct {
}
func (*validateOpGetSuiteDefinition) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetSuiteDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetSuiteDefinitionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetSuiteDefinitionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetSuiteRun struct {
}
func (*validateOpGetSuiteRun) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetSuiteRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetSuiteRunInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetSuiteRunInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetSuiteRunReport struct {
}
func (*validateOpGetSuiteRunReport) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetSuiteRunReport) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetSuiteRunReportInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetSuiteRunReportInput(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 validateOpStartSuiteRun struct {
}
func (*validateOpStartSuiteRun) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartSuiteRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartSuiteRunInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartSuiteRunInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStopSuiteRun struct {
}
func (*validateOpStopSuiteRun) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStopSuiteRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StopSuiteRunInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStopSuiteRunInput(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)
}
type validateOpUpdateSuiteDefinition struct {
}
func (*validateOpUpdateSuiteDefinition) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateSuiteDefinition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateSuiteDefinitionInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateSuiteDefinitionInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpCreateSuiteDefinitionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateSuiteDefinition{}, middleware.After)
}
func addOpDeleteSuiteDefinitionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteSuiteDefinition{}, middleware.After)
}
func addOpGetSuiteDefinitionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetSuiteDefinition{}, middleware.After)
}
func addOpGetSuiteRunValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetSuiteRun{}, middleware.After)
}
func addOpGetSuiteRunReportValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetSuiteRunReport{}, middleware.After)
}
func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
}
func addOpStartSuiteRunValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartSuiteRun{}, middleware.After)
}
func addOpStopSuiteRunValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStopSuiteRun{}, 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 addOpUpdateSuiteDefinitionValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateSuiteDefinition{}, middleware.After)
}
func validateSuiteDefinitionConfiguration(v *types.SuiteDefinitionConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SuiteDefinitionConfiguration"}
if v.SuiteDefinitionName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SuiteDefinitionName"))
}
if v.RootGroup == nil {
invalidParams.Add(smithy.NewErrParamRequired("RootGroup"))
}
if v.DevicePermissionRoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("DevicePermissionRoleArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSuiteRunConfiguration(v *types.SuiteRunConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SuiteRunConfiguration"}
if v.PrimaryDevice == nil {
invalidParams.Add(smithy.NewErrParamRequired("PrimaryDevice"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateSuiteDefinitionInput(v *CreateSuiteDefinitionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateSuiteDefinitionInput"}
if v.SuiteDefinitionConfiguration == nil {
invalidParams.Add(smithy.NewErrParamRequired("SuiteDefinitionConfiguration"))
} else if v.SuiteDefinitionConfiguration != nil {
if err := validateSuiteDefinitionConfiguration(v.SuiteDefinitionConfiguration); err != nil {
invalidParams.AddNested("SuiteDefinitionConfiguration", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteSuiteDefinitionInput(v *DeleteSuiteDefinitionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteSuiteDefinitionInput"}
if v.SuiteDefinitionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SuiteDefinitionId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetSuiteDefinitionInput(v *GetSuiteDefinitionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetSuiteDefinitionInput"}
if v.SuiteDefinitionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SuiteDefinitionId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetSuiteRunInput(v *GetSuiteRunInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetSuiteRunInput"}
if v.SuiteDefinitionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SuiteDefinitionId"))
}
if v.SuiteRunId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SuiteRunId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetSuiteRunReportInput(v *GetSuiteRunReportInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetSuiteRunReportInput"}
if v.SuiteDefinitionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SuiteDefinitionId"))
}
if v.SuiteRunId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SuiteRunId"))
}
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 validateOpStartSuiteRunInput(v *StartSuiteRunInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartSuiteRunInput"}
if v.SuiteDefinitionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SuiteDefinitionId"))
}
if v.SuiteRunConfiguration == nil {
invalidParams.Add(smithy.NewErrParamRequired("SuiteRunConfiguration"))
} else if v.SuiteRunConfiguration != nil {
if err := validateSuiteRunConfiguration(v.SuiteRunConfiguration); err != nil {
invalidParams.AddNested("SuiteRunConfiguration", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStopSuiteRunInput(v *StopSuiteRunInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StopSuiteRunInput"}
if v.SuiteDefinitionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SuiteDefinitionId"))
}
if v.SuiteRunId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SuiteRunId"))
}
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
}
}
func validateOpUpdateSuiteDefinitionInput(v *UpdateSuiteDefinitionInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateSuiteDefinitionInput"}
if v.SuiteDefinitionId == nil {
invalidParams.Add(smithy.NewErrParamRequired("SuiteDefinitionId"))
}
if v.SuiteDefinitionConfiguration == nil {
invalidParams.Add(smithy.NewErrParamRequired("SuiteDefinitionConfiguration"))
} else if v.SuiteDefinitionConfiguration != nil {
if err := validateSuiteDefinitionConfiguration(v.SuiteDefinitionConfiguration); err != nil {
invalidParams.AddNested("SuiteDefinitionConfiguration", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 510 |
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 IotDeviceAdvisor 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: "api.iotdeviceadvisor.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "api.iotdeviceadvisor-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "api.iotdeviceadvisor-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.iotdeviceadvisor.{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{
Hostname: "api.iotdeviceadvisor.ap-northeast-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "ap-northeast-1",
},
},
endpoints.EndpointKey{
Region: "eu-west-1",
}: endpoints.Endpoint{
Hostname: "api.iotdeviceadvisor.eu-west-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "eu-west-1",
},
},
endpoints.EndpointKey{
Region: "us-east-1",
}: endpoints.Endpoint{
Hostname: "api.iotdeviceadvisor.us-east-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-east-1",
},
},
endpoints.EndpointKey{
Region: "us-west-2",
}: endpoints.Endpoint{
Hostname: "api.iotdeviceadvisor.us-west-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-west-2",
},
},
},
},
{
ID: "aws-cn",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "api.iotdeviceadvisor.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "api.iotdeviceadvisor-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "api.iotdeviceadvisor-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.iotdeviceadvisor.{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: "api.iotdeviceadvisor-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.iotdeviceadvisor.{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: "api.iotdeviceadvisor-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.iotdeviceadvisor.{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: "api.iotdeviceadvisor-fips.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.iotdeviceadvisor.{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: "api.iotdeviceadvisor-fips.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.iotdeviceadvisor.{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: "api.iotdeviceadvisor.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "api.iotdeviceadvisor-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "api.iotdeviceadvisor-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.iotdeviceadvisor.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: true,
},
}
| 331 |
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 AuthenticationMethod string
// Enum values for AuthenticationMethod
const (
AuthenticationMethodX509ClientCertificate AuthenticationMethod = "X509ClientCertificate"
AuthenticationMethodSignatureVersion4 AuthenticationMethod = "SignatureVersion4"
)
// Values returns all known values for AuthenticationMethod. 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 (AuthenticationMethod) Values() []AuthenticationMethod {
return []AuthenticationMethod{
"X509ClientCertificate",
"SignatureVersion4",
}
}
type Protocol string
// Enum values for Protocol
const (
ProtocolMqttV311 Protocol = "MqttV3_1_1"
ProtocolMqttV5 Protocol = "MqttV5"
ProtocolMqttV311OverWebSocket Protocol = "MqttV3_1_1_OverWebSocket"
ProtocolMqttV5OverWebSocket Protocol = "MqttV5_OverWebSocket"
)
// Values returns all known values for Protocol. 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 (Protocol) Values() []Protocol {
return []Protocol{
"MqttV3_1_1",
"MqttV5",
"MqttV3_1_1_OverWebSocket",
"MqttV5_OverWebSocket",
}
}
type Status string
// Enum values for Status
const (
StatusPass Status = "PASS"
StatusFail Status = "FAIL"
StatusCanceled Status = "CANCELED"
StatusPending Status = "PENDING"
StatusRunning Status = "RUNNING"
StatusStopping Status = "STOPPING"
StatusStopped Status = "STOPPED"
StatusPassWithWarnings Status = "PASS_WITH_WARNINGS"
StatusError Status = "ERROR"
)
// Values returns all known values for Status. 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 (Status) Values() []Status {
return []Status{
"PASS",
"FAIL",
"CANCELED",
"PENDING",
"RUNNING",
"STOPPING",
"STOPPED",
"PASS_WITH_WARNINGS",
"ERROR",
}
}
type SuiteRunStatus string
// Enum values for SuiteRunStatus
const (
SuiteRunStatusPass SuiteRunStatus = "PASS"
SuiteRunStatusFail SuiteRunStatus = "FAIL"
SuiteRunStatusCanceled SuiteRunStatus = "CANCELED"
SuiteRunStatusPending SuiteRunStatus = "PENDING"
SuiteRunStatusRunning SuiteRunStatus = "RUNNING"
SuiteRunStatusStopping SuiteRunStatus = "STOPPING"
SuiteRunStatusStopped SuiteRunStatus = "STOPPED"
SuiteRunStatusPassWithWarnings SuiteRunStatus = "PASS_WITH_WARNINGS"
SuiteRunStatusError SuiteRunStatus = "ERROR"
)
// Values returns all known values for SuiteRunStatus. 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 (SuiteRunStatus) Values() []SuiteRunStatus {
return []SuiteRunStatus{
"PASS",
"FAIL",
"CANCELED",
"PENDING",
"RUNNING",
"STOPPING",
"STOPPED",
"PASS_WITH_WARNINGS",
"ERROR",
}
}
type TestCaseScenarioStatus string
// Enum values for TestCaseScenarioStatus
const (
TestCaseScenarioStatusPass TestCaseScenarioStatus = "PASS"
TestCaseScenarioStatusFail TestCaseScenarioStatus = "FAIL"
TestCaseScenarioStatusCanceled TestCaseScenarioStatus = "CANCELED"
TestCaseScenarioStatusPending TestCaseScenarioStatus = "PENDING"
TestCaseScenarioStatusRunning TestCaseScenarioStatus = "RUNNING"
TestCaseScenarioStatusStopping TestCaseScenarioStatus = "STOPPING"
TestCaseScenarioStatusStopped TestCaseScenarioStatus = "STOPPED"
TestCaseScenarioStatusPassWithWarnings TestCaseScenarioStatus = "PASS_WITH_WARNINGS"
TestCaseScenarioStatusError TestCaseScenarioStatus = "ERROR"
)
// Values returns all known values for TestCaseScenarioStatus. 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 (TestCaseScenarioStatus) Values() []TestCaseScenarioStatus {
return []TestCaseScenarioStatus{
"PASS",
"FAIL",
"CANCELED",
"PENDING",
"RUNNING",
"STOPPING",
"STOPPED",
"PASS_WITH_WARNINGS",
"ERROR",
}
}
type TestCaseScenarioType string
// Enum values for TestCaseScenarioType
const (
TestCaseScenarioTypeAdvanced TestCaseScenarioType = "Advanced"
TestCaseScenarioTypeBasic TestCaseScenarioType = "Basic"
)
// Values returns all known values for TestCaseScenarioType. 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 (TestCaseScenarioType) Values() []TestCaseScenarioType {
return []TestCaseScenarioType{
"Advanced",
"Basic",
}
}
| 158 |
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"
)
// Sends a Conflict Exception.
type ConflictException struct {
Message *string
ErrorCodeOverride *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 }
// Sends an Internal Failure exception.
type InternalServerException struct {
Message *string
ErrorCodeOverride *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 }
// Sends a Resource Not Found exception.
type ResourceNotFoundException struct {
Message *string
ErrorCodeOverride *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 }
// Sends a validation exception.
type ValidationException struct {
Message *string
ErrorCodeOverride *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 }
| 113 |
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 of a test device. A thing ARN, certificate ARN or device role ARN
// is required.
type DeviceUnderTest struct {
// Lists device's certificate ARN.
CertificateArn *string
// Lists device's role ARN.
DeviceRoleArn *string
// Lists device's thing ARN.
ThingArn *string
noSmithyDocumentSerde
}
// Show Group Result.
type GroupResult struct {
// Group result ID.
GroupId *string
// Group Result Name.
GroupName *string
// Tests under Group Result.
Tests []TestCaseRun
noSmithyDocumentSerde
}
// Gets the suite definition configuration.
type SuiteDefinitionConfiguration struct {
// Gets the device permission ARN. This is a required parameter.
//
// This member is required.
DevicePermissionRoleArn *string
// Gets the test suite root group. This is a required parameter. For updating or
// creating the latest qualification suite, if intendedForQualification is set to
// true, rootGroup can be an empty string. If intendedForQualification is false,
// rootGroup cannot be an empty string. If rootGroup is empty, and
// intendedForQualification is set to true, all the qualification tests are
// included, and the configuration is default. For a qualification suite, the
// minimum length is 0, and the maximum is 2048. For a non-qualification suite, the
// minimum length is 1, and the maximum is 2048.
//
// This member is required.
RootGroup *string
// Gets the suite definition name. This is a required parameter.
//
// This member is required.
SuiteDefinitionName *string
// Gets the devices configured.
Devices []DeviceUnderTest
// Gets the tests intended for qualification in a suite.
IntendedForQualification bool
// Verifies if the test suite is a long duration test.
IsLongDurationTest bool
// Sets the MQTT protocol that is configured in the suite definition.
Protocol Protocol
noSmithyDocumentSerde
}
// Information about the suite definition.
type SuiteDefinitionInformation struct {
// Date (in Unix epoch time) when the test suite was created.
CreatedAt *time.Time
// Specifies the devices that are under test for the test suite.
DefaultDevices []DeviceUnderTest
// Specifies if the test suite is intended for qualification.
IntendedForQualification bool
// Verifies if the test suite is a long duration test.
IsLongDurationTest bool
// Gets the MQTT protocol that is configured in the suite definition.
Protocol Protocol
// Suite definition ID of the test suite.
SuiteDefinitionId *string
// Suite name of the test suite.
SuiteDefinitionName *string
noSmithyDocumentSerde
}
// Gets suite run configuration.
type SuiteRunConfiguration struct {
// Sets the primary device for the test suite run. This requires a thing ARN or a
// certificate ARN.
//
// This member is required.
PrimaryDevice *DeviceUnderTest
// TRUE if multiple test suites run in parallel.
ParallelRun bool
// Sets test case list.
SelectedTestList []string
noSmithyDocumentSerde
}
// Information about the suite run. Requires permission to access the
// SuiteRunInformation (https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-actions-as-permissions)
// action.
type SuiteRunInformation struct {
// Date (in Unix epoch time) when the suite run was created.
CreatedAt *time.Time
// Date (in Unix epoch time) when the suite run ended.
EndAt *time.Time
// Number of test cases that failed in the suite run.
Failed int32
// Number of test cases that passed in the suite run.
Passed int32
// Date (in Unix epoch time) when the suite run was started.
StartedAt *time.Time
// Status of the suite run.
Status SuiteRunStatus
// Suite definition ID of the suite run.
SuiteDefinitionId *string
// Suite definition name of the suite run.
SuiteDefinitionName *string
// Suite definition version of the suite run.
SuiteDefinitionVersion *string
// Suite run ID of the suite run.
SuiteRunId *string
noSmithyDocumentSerde
}
// Provides the test case run.
type TestCaseRun struct {
// Provides test case run end time.
EndTime *time.Time
// Provides test case run failure result.
Failure *string
// Provides test case run log URL.
LogUrl *string
// Provides test case run start time.
StartTime *time.Time
// Provides the test case run status. Status is one of the following:
// - PASS : Test passed.
// - FAIL : Test failed.
// - PENDING : Test has not started running but is scheduled.
// - RUNNING : Test is running.
// - STOPPING : Test is performing cleanup steps. You will see this status only
// if you stop a suite run.
// - STOPPED Test is stopped. You will see this status only if you stop a suite
// run.
// - PASS_WITH_WARNINGS : Test passed with warnings.
// - ERORR : Test faced an error when running due to an internal issue.
Status Status
// Provides the test case run definition ID.
TestCaseDefinitionId *string
// Provides the test case run definition name.
TestCaseDefinitionName *string
// Provides the test case run ID.
TestCaseRunId *string
// Provides the test scenarios for the test case run.
TestScenarios []TestCaseScenario
// Provides test case run warnings.
Warnings *string
noSmithyDocumentSerde
}
// Provides test case scenario.
type TestCaseScenario struct {
// Provides test case scenario failure result.
Failure *string
// Provides the test case scenario status. Status is one of the following:
// - PASS : Test passed.
// - FAIL : Test failed.
// - PENDING : Test has not started running but is scheduled.
// - RUNNING : Test is running.
// - STOPPING : Test is performing cleanup steps. You will see this status only
// if you stop a suite run.
// - STOPPED Test is stopped. You will see this status only if you stop a suite
// run.
// - PASS_WITH_WARNINGS : Test passed with warnings.
// - ERORR : Test faced an error when running due to an internal issue.
Status TestCaseScenarioStatus
// Provides test case scenario system messages if any.
SystemMessage *string
// Provides test case scenario ID.
TestCaseScenarioId *string
// Provides test case scenario type. Type is one of the following:
// - Advanced
// - Basic
TestCaseScenarioType TestCaseScenarioType
noSmithyDocumentSerde
}
// Show each group result.
type TestResult struct {
// Show each group of test results.
Groups []GroupResult
noSmithyDocumentSerde
}
type noSmithyDocumentSerde = smithydocument.NoSerde
| 253 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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 = "IoT Events"
const ServiceAPIVersion = "2018-07-27"
// Client provides the API client to make operations call for AWS IoT Events.
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, "iotevents", 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)
}
| 434 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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 iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Creates an alarm model to monitor an AWS IoT Events input attribute. You can
// use the alarm to get notified when the value is outside a specified range. For
// more information, see Create an alarm model (https://docs.aws.amazon.com/iotevents/latest/developerguide/create-alarms.html)
// in the AWS IoT Events Developer Guide.
func (c *Client) CreateAlarmModel(ctx context.Context, params *CreateAlarmModelInput, optFns ...func(*Options)) (*CreateAlarmModelOutput, error) {
if params == nil {
params = &CreateAlarmModelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateAlarmModel", params, optFns, c.addOperationCreateAlarmModelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateAlarmModelOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateAlarmModelInput struct {
// A unique name that helps you identify the alarm model. You can't change this
// name after you create the alarm model.
//
// This member is required.
AlarmModelName *string
// Defines when your alarm is invoked.
//
// This member is required.
AlarmRule *types.AlarmRule
// The ARN of the IAM role that allows the alarm to perform actions and access AWS
// resources. For more information, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
// in the AWS General Reference.
//
// This member is required.
RoleArn *string
// Contains the configuration information of alarm state changes.
AlarmCapabilities *types.AlarmCapabilities
// Contains information about one or more alarm actions.
AlarmEventActions *types.AlarmEventActions
// A description that tells you what the alarm model detects.
AlarmModelDescription *string
// Contains information about one or more notification actions.
AlarmNotification *types.AlarmNotification
// An input attribute used as a key to create an alarm. AWS IoT Events routes
// inputs (https://docs.aws.amazon.com/iotevents/latest/apireference/API_Input.html)
// associated with this key to the alarm.
Key *string
// A non-negative integer that reflects the severity level of the alarm.
Severity *int32
// A list of key-value pairs that contain metadata for the alarm model. The tags
// help you manage the alarm model. For more information, see Tagging your AWS IoT
// Events resources (https://docs.aws.amazon.com/iotevents/latest/developerguide/tagging-iotevents.html)
// in the AWS IoT Events Developer Guide. You can create up to 50 tags for one
// alarm model.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateAlarmModelOutput struct {
// The ARN of the alarm model. For more information, see Amazon Resource Names
// (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
// in the AWS General Reference.
AlarmModelArn *string
// The version of the alarm model.
AlarmModelVersion *string
// The time the alarm model was created, in the Unix epoch format.
CreationTime *time.Time
// The time the alarm model was last updated, in the Unix epoch format.
LastUpdateTime *time.Time
// The status of the alarm model. The status can be one of the following values:
// - ACTIVE - The alarm model is active and it's ready to evaluate data.
// - ACTIVATING - AWS IoT Events is activating your alarm model. Activating an
// alarm model can take up to a few minutes.
// - INACTIVE - The alarm model is inactive, so it isn't ready to evaluate data.
// Check your alarm model information and update the alarm model.
// - FAILED - You couldn't create or update the alarm model. Check your alarm
// model information and try again.
Status types.AlarmModelVersionStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateAlarmModelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateAlarmModel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateAlarmModel{}, 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 = addOpCreateAlarmModelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateAlarmModel(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_opCreateAlarmModel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "CreateAlarmModel",
}
}
| 190 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a detector model.
func (c *Client) CreateDetectorModel(ctx context.Context, params *CreateDetectorModelInput, optFns ...func(*Options)) (*CreateDetectorModelOutput, error) {
if params == nil {
params = &CreateDetectorModelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateDetectorModel", params, optFns, c.addOperationCreateDetectorModelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateDetectorModelOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateDetectorModelInput struct {
// Information that defines how the detectors operate.
//
// This member is required.
DetectorModelDefinition *types.DetectorModelDefinition
// The name of the detector model.
//
// This member is required.
DetectorModelName *string
// The ARN of the role that grants permission to AWS IoT Events to perform its
// operations.
//
// This member is required.
RoleArn *string
// A brief description of the detector model.
DetectorModelDescription *string
// Information about the order in which events are evaluated and how actions are
// executed.
EvaluationMethod types.EvaluationMethod
// The input attribute key used to identify a device or system to create a
// detector (an instance of the detector model) and then to route each input
// received to the appropriate detector (instance). This parameter uses a JSON-path
// expression in the message payload of each input to specify the attribute-value
// pair that is used to identify the device associated with the input.
Key *string
// Metadata that can be used to manage the detector model.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateDetectorModelOutput struct {
// Information about how the detector model is configured.
DetectorModelConfiguration *types.DetectorModelConfiguration
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateDetectorModelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateDetectorModel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateDetectorModel{}, 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 = addOpCreateDetectorModelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateDetectorModel(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_opCreateDetectorModel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "CreateDetectorModel",
}
}
| 153 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an input.
func (c *Client) CreateInput(ctx context.Context, params *CreateInputInput, optFns ...func(*Options)) (*CreateInputOutput, error) {
if params == nil {
params = &CreateInputInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateInput", params, optFns, c.addOperationCreateInputMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateInputOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateInputInput struct {
// The definition of the input.
//
// This member is required.
InputDefinition *types.InputDefinition
// The name you want to give to the input.
//
// This member is required.
InputName *string
// A brief description of the input.
InputDescription *string
// Metadata that can be used to manage the input.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateInputOutput struct {
// Information about the configuration of the input.
InputConfiguration *types.InputConfiguration
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateInputMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateInput{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateInput{}, 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 = addOpCreateInputValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateInput(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_opCreateInput(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "CreateInput",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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 an alarm model. Any alarm instances that were created based on this
// alarm model are also deleted. This action can't be undone.
func (c *Client) DeleteAlarmModel(ctx context.Context, params *DeleteAlarmModelInput, optFns ...func(*Options)) (*DeleteAlarmModelOutput, error) {
if params == nil {
params = &DeleteAlarmModelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteAlarmModel", params, optFns, c.addOperationDeleteAlarmModelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteAlarmModelOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteAlarmModelInput struct {
// The name of the alarm model.
//
// This member is required.
AlarmModelName *string
noSmithyDocumentSerde
}
type DeleteAlarmModelOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteAlarmModelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteAlarmModel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteAlarmModel{}, 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 = addOpDeleteAlarmModelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteAlarmModel(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_opDeleteAlarmModel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "DeleteAlarmModel",
}
}
| 121 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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 a detector model. Any active instances of the detector model are also
// deleted.
func (c *Client) DeleteDetectorModel(ctx context.Context, params *DeleteDetectorModelInput, optFns ...func(*Options)) (*DeleteDetectorModelOutput, error) {
if params == nil {
params = &DeleteDetectorModelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteDetectorModel", params, optFns, c.addOperationDeleteDetectorModelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteDetectorModelOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteDetectorModelInput struct {
// The name of the detector model to be deleted.
//
// This member is required.
DetectorModelName *string
noSmithyDocumentSerde
}
type DeleteDetectorModelOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteDetectorModelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteDetectorModel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteDetectorModel{}, 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 = addOpDeleteDetectorModelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteDetectorModel(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_opDeleteDetectorModel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "DeleteDetectorModel",
}
}
| 121 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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 an input.
func (c *Client) DeleteInput(ctx context.Context, params *DeleteInputInput, optFns ...func(*Options)) (*DeleteInputOutput, error) {
if params == nil {
params = &DeleteInputInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteInput", params, optFns, c.addOperationDeleteInputMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteInputOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteInputInput struct {
// The name of the input to delete.
//
// This member is required.
InputName *string
noSmithyDocumentSerde
}
type DeleteInputOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteInputMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteInput{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteInput{}, 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 = addOpDeleteInputValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteInput(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_opDeleteInput(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "DeleteInput",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Retrieves information about an alarm model. If you don't specify a value for
// the alarmModelVersion parameter, the latest version is returned.
func (c *Client) DescribeAlarmModel(ctx context.Context, params *DescribeAlarmModelInput, optFns ...func(*Options)) (*DescribeAlarmModelOutput, error) {
if params == nil {
params = &DescribeAlarmModelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeAlarmModel", params, optFns, c.addOperationDescribeAlarmModelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeAlarmModelOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeAlarmModelInput struct {
// The name of the alarm model.
//
// This member is required.
AlarmModelName *string
// The version of the alarm model.
AlarmModelVersion *string
noSmithyDocumentSerde
}
type DescribeAlarmModelOutput struct {
// Contains the configuration information of alarm state changes.
AlarmCapabilities *types.AlarmCapabilities
// Contains information about one or more alarm actions.
AlarmEventActions *types.AlarmEventActions
// The ARN of the alarm model. For more information, see Amazon Resource Names
// (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
// in the AWS General Reference.
AlarmModelArn *string
// The description of the alarm model.
AlarmModelDescription *string
// The name of the alarm model.
AlarmModelName *string
// The version of the alarm model.
AlarmModelVersion *string
// Contains information about one or more notification actions.
AlarmNotification *types.AlarmNotification
// Defines when your alarm is invoked.
AlarmRule *types.AlarmRule
// The time the alarm model was created, in the Unix epoch format.
CreationTime *time.Time
// An input attribute used as a key to create an alarm. AWS IoT Events routes
// inputs (https://docs.aws.amazon.com/iotevents/latest/apireference/API_Input.html)
// associated with this key to the alarm.
Key *string
// The time the alarm model was last updated, in the Unix epoch format.
LastUpdateTime *time.Time
// The ARN of the IAM role that allows the alarm to perform actions and access AWS
// resources. For more information, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
// in the AWS General Reference.
RoleArn *string
// A non-negative integer that reflects the severity level of the alarm.
Severity *int32
// The status of the alarm model. The status can be one of the following values:
// - ACTIVE - The alarm model is active and it's ready to evaluate data.
// - ACTIVATING - AWS IoT Events is activating your alarm model. Activating an
// alarm model can take up to a few minutes.
// - INACTIVE - The alarm model is inactive, so it isn't ready to evaluate data.
// Check your alarm model information and update the alarm model.
// - FAILED - You couldn't create or update the alarm model. Check your alarm
// model information and try again.
Status types.AlarmModelVersionStatus
// Contains information about the status of the alarm model.
StatusMessage *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeAlarmModelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeAlarmModel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeAlarmModel{}, 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 = addOpDescribeAlarmModelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeAlarmModel(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_opDescribeAlarmModel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "DescribeAlarmModel",
}
}
| 185 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes a detector model. If the version parameter is not specified,
// information about the latest version is returned.
func (c *Client) DescribeDetectorModel(ctx context.Context, params *DescribeDetectorModelInput, optFns ...func(*Options)) (*DescribeDetectorModelOutput, error) {
if params == nil {
params = &DescribeDetectorModelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDetectorModel", params, optFns, c.addOperationDescribeDetectorModelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDetectorModelOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDetectorModelInput struct {
// The name of the detector model.
//
// This member is required.
DetectorModelName *string
// The version of the detector model.
DetectorModelVersion *string
noSmithyDocumentSerde
}
type DescribeDetectorModelOutput struct {
// Information about the detector model.
DetectorModel *types.DetectorModel
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDetectorModelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeDetectorModel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeDetectorModel{}, 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 = addOpDescribeDetectorModelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDetectorModel(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_opDescribeDetectorModel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "DescribeDetectorModel",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves runtime information about a detector model analysis. After AWS IoT
// Events starts analyzing your detector model, you have up to 24 hours to retrieve
// the analysis results.
func (c *Client) DescribeDetectorModelAnalysis(ctx context.Context, params *DescribeDetectorModelAnalysisInput, optFns ...func(*Options)) (*DescribeDetectorModelAnalysisOutput, error) {
if params == nil {
params = &DescribeDetectorModelAnalysisInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDetectorModelAnalysis", params, optFns, c.addOperationDescribeDetectorModelAnalysisMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDetectorModelAnalysisOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDetectorModelAnalysisInput struct {
// The ID of the analysis result that you want to retrieve.
//
// This member is required.
AnalysisId *string
noSmithyDocumentSerde
}
type DescribeDetectorModelAnalysisOutput struct {
// The status of the analysis activity. The status can be one of the following
// values:
// - RUNNING - AWS IoT Events is analyzing your detector model. This process can
// take several minutes to complete.
// - COMPLETE - AWS IoT Events finished analyzing your detector model.
// - FAILED - AWS IoT Events couldn't analyze your detector model. Try again
// later.
Status types.AnalysisStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDetectorModelAnalysisMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeDetectorModelAnalysis{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeDetectorModelAnalysis{}, 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 = addOpDescribeDetectorModelAnalysisValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDetectorModelAnalysis(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_opDescribeDetectorModelAnalysis(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "DescribeDetectorModelAnalysis",
}
}
| 133 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Describes an input.
func (c *Client) DescribeInput(ctx context.Context, params *DescribeInputInput, optFns ...func(*Options)) (*DescribeInputOutput, error) {
if params == nil {
params = &DescribeInputInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeInput", params, optFns, c.addOperationDescribeInputMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeInputOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeInputInput struct {
// The name of the input.
//
// This member is required.
InputName *string
noSmithyDocumentSerde
}
type DescribeInputOutput struct {
// Information about the input.
Input *types.Input
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeInputMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeInput{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeInput{}, 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 = addOpDescribeInputValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeInput(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_opDescribeInput(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "DescribeInput",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves the current settings of the AWS IoT Events logging options.
func (c *Client) DescribeLoggingOptions(ctx context.Context, params *DescribeLoggingOptionsInput, optFns ...func(*Options)) (*DescribeLoggingOptionsOutput, error) {
if params == nil {
params = &DescribeLoggingOptionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeLoggingOptions", params, optFns, c.addOperationDescribeLoggingOptionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeLoggingOptionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeLoggingOptionsInput struct {
noSmithyDocumentSerde
}
type DescribeLoggingOptionsOutput struct {
// The current settings of the AWS IoT Events logging options.
LoggingOptions *types.LoggingOptions
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeLoggingOptionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeLoggingOptions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeLoggingOptions{}, 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_opDescribeLoggingOptions(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_opDescribeLoggingOptions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "DescribeLoggingOptions",
}
}
| 116 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves one or more analysis results of the detector model. After AWS IoT
// Events starts analyzing your detector model, you have up to 24 hours to retrieve
// the analysis results.
func (c *Client) GetDetectorModelAnalysisResults(ctx context.Context, params *GetDetectorModelAnalysisResultsInput, optFns ...func(*Options)) (*GetDetectorModelAnalysisResultsOutput, error) {
if params == nil {
params = &GetDetectorModelAnalysisResultsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetDetectorModelAnalysisResults", params, optFns, c.addOperationGetDetectorModelAnalysisResultsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetDetectorModelAnalysisResultsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetDetectorModelAnalysisResultsInput struct {
// The ID of the analysis result that you want to retrieve.
//
// This member is required.
AnalysisId *string
// The maximum number of results to be returned per request.
MaxResults *int32
// The token that you can use to return the next set of results.
NextToken *string
noSmithyDocumentSerde
}
type GetDetectorModelAnalysisResultsOutput struct {
// Contains information about one or more analysis results.
AnalysisResults []types.AnalysisResult
// The token that you can use to return the next set of results, or null if there
// are no more results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetDetectorModelAnalysisResultsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetDetectorModelAnalysisResults{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetDetectorModelAnalysisResults{}, 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 = addOpGetDetectorModelAnalysisResultsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetDetectorModelAnalysisResults(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_opGetDetectorModelAnalysisResults(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "GetDetectorModelAnalysisResults",
}
}
| 137 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the alarm models that you created. The operation returns only the
// metadata associated with each alarm model.
func (c *Client) ListAlarmModels(ctx context.Context, params *ListAlarmModelsInput, optFns ...func(*Options)) (*ListAlarmModelsOutput, error) {
if params == nil {
params = &ListAlarmModelsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListAlarmModels", params, optFns, c.addOperationListAlarmModelsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListAlarmModelsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListAlarmModelsInput struct {
// The maximum number of results to be returned per request.
MaxResults *int32
// The token that you can use to return the next set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListAlarmModelsOutput struct {
// A list that summarizes each alarm model.
AlarmModelSummaries []types.AlarmModelSummary
// The token that you can use to return the next set of results, or null if there
// are no more results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListAlarmModelsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListAlarmModels{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListAlarmModels{}, 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_opListAlarmModels(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_opListAlarmModels(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "ListAlarmModels",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all the versions of an alarm model. The operation returns only the
// metadata associated with each alarm model version.
func (c *Client) ListAlarmModelVersions(ctx context.Context, params *ListAlarmModelVersionsInput, optFns ...func(*Options)) (*ListAlarmModelVersionsOutput, error) {
if params == nil {
params = &ListAlarmModelVersionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListAlarmModelVersions", params, optFns, c.addOperationListAlarmModelVersionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListAlarmModelVersionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListAlarmModelVersionsInput struct {
// The name of the alarm model.
//
// This member is required.
AlarmModelName *string
// The maximum number of results to be returned per request.
MaxResults *int32
// The token that you can use to return the next set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListAlarmModelVersionsOutput struct {
// A list that summarizes each alarm model version.
AlarmModelVersionSummaries []types.AlarmModelVersionSummary
// The token that you can use to return the next set of results, or null if there
// are no more results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListAlarmModelVersionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListAlarmModelVersions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListAlarmModelVersions{}, 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 = addOpListAlarmModelVersionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListAlarmModelVersions(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_opListAlarmModelVersions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "ListAlarmModelVersions",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the detector models you have created. Only the metadata associated with
// each detector model is returned.
func (c *Client) ListDetectorModels(ctx context.Context, params *ListDetectorModelsInput, optFns ...func(*Options)) (*ListDetectorModelsOutput, error) {
if params == nil {
params = &ListDetectorModelsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDetectorModels", params, optFns, c.addOperationListDetectorModelsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDetectorModelsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDetectorModelsInput struct {
// The maximum number of results to be returned per request.
MaxResults *int32
// The token that you can use to return the next set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListDetectorModelsOutput struct {
// Summary information about the detector models.
DetectorModelSummaries []types.DetectorModelSummary
// The token that you can use to return the next set of results, or null if there
// are no more results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDetectorModelsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListDetectorModels{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListDetectorModels{}, 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_opListDetectorModels(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_opListDetectorModels(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "ListDetectorModels",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all the versions of a detector model. Only the metadata associated with
// each detector model version is returned.
func (c *Client) ListDetectorModelVersions(ctx context.Context, params *ListDetectorModelVersionsInput, optFns ...func(*Options)) (*ListDetectorModelVersionsOutput, error) {
if params == nil {
params = &ListDetectorModelVersionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDetectorModelVersions", params, optFns, c.addOperationListDetectorModelVersionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDetectorModelVersionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDetectorModelVersionsInput struct {
// The name of the detector model whose versions are returned.
//
// This member is required.
DetectorModelName *string
// The maximum number of results to be returned per request.
MaxResults *int32
// The token that you can use to return the next set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListDetectorModelVersionsOutput struct {
// Summary information about the detector model versions.
DetectorModelVersionSummaries []types.DetectorModelVersionSummary
// The token that you can use to return the next set of results, or null if there
// are no more results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDetectorModelVersionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListDetectorModelVersions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListDetectorModelVersions{}, 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 = addOpListDetectorModelVersionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListDetectorModelVersions(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_opListDetectorModelVersions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "ListDetectorModelVersions",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists one or more input routings.
func (c *Client) ListInputRoutings(ctx context.Context, params *ListInputRoutingsInput, optFns ...func(*Options)) (*ListInputRoutingsOutput, error) {
if params == nil {
params = &ListInputRoutingsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListInputRoutings", params, optFns, c.addOperationListInputRoutingsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListInputRoutingsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListInputRoutingsInput struct {
// The identifer of the routed input.
//
// This member is required.
InputIdentifier *types.InputIdentifier
// The maximum number of results to be returned per request.
MaxResults *int32
// The token that you can use to return the next set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListInputRoutingsOutput struct {
// The token that you can use to return the next set of results, or null if there
// are no more results.
NextToken *string
// Summary information about the routed resources.
RoutedResources []types.RoutedResource
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListInputRoutingsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListInputRoutings{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListInputRoutings{}, 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 = addOpListInputRoutingsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListInputRoutings(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_opListInputRoutings(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "ListInputRoutings",
}
}
| 135 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the inputs you have created.
func (c *Client) ListInputs(ctx context.Context, params *ListInputsInput, optFns ...func(*Options)) (*ListInputsOutput, error) {
if params == nil {
params = &ListInputsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListInputs", params, optFns, c.addOperationListInputsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListInputsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListInputsInput struct {
// The maximum number of results to be returned per request.
MaxResults *int32
// The token that you can use to return the next set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListInputsOutput struct {
// Summary information about the inputs.
InputSummaries []types.InputSummary
// The token that you can use to return the next set of results, or null if there
// are no more results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListInputsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListInputs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListInputs{}, 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_opListInputs(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_opListInputs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "ListInputs",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the tags (metadata) you have assigned 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 ARN of the resource.
//
// This member is required.
ResourceArn *string
noSmithyDocumentSerde
}
type ListTagsForResourceOutput struct {
// The list of tags assigned to the resource.
Tags []types.Tag
// 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: "iotevents",
OperationName: "ListTagsForResource",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Sets or updates the AWS IoT Events logging options. If you update the value of
// any loggingOptions field, it takes up to one minute for the change to take
// effect. If you change the policy attached to the role you specified in the
// roleArn field (for example, to correct an invalid policy), it takes up to five
// minutes for that change to take effect.
func (c *Client) PutLoggingOptions(ctx context.Context, params *PutLoggingOptionsInput, optFns ...func(*Options)) (*PutLoggingOptionsOutput, error) {
if params == nil {
params = &PutLoggingOptionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "PutLoggingOptions", params, optFns, c.addOperationPutLoggingOptionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*PutLoggingOptionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type PutLoggingOptionsInput struct {
// The new values of the AWS IoT Events logging options.
//
// This member is required.
LoggingOptions *types.LoggingOptions
noSmithyDocumentSerde
}
type PutLoggingOptionsOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationPutLoggingOptionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpPutLoggingOptions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpPutLoggingOptions{}, 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 = addOpPutLoggingOptionsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutLoggingOptions(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_opPutLoggingOptions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "PutLoggingOptions",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Performs an analysis of your detector model. For more information, see
// Troubleshooting a detector model (https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-analyze-api.html)
// in the AWS IoT Events Developer Guide.
func (c *Client) StartDetectorModelAnalysis(ctx context.Context, params *StartDetectorModelAnalysisInput, optFns ...func(*Options)) (*StartDetectorModelAnalysisOutput, error) {
if params == nil {
params = &StartDetectorModelAnalysisInput{}
}
result, metadata, err := c.invokeOperation(ctx, "StartDetectorModelAnalysis", params, optFns, c.addOperationStartDetectorModelAnalysisMiddlewares)
if err != nil {
return nil, err
}
out := result.(*StartDetectorModelAnalysisOutput)
out.ResultMetadata = metadata
return out, nil
}
type StartDetectorModelAnalysisInput struct {
// Information that defines how a detector operates.
//
// This member is required.
DetectorModelDefinition *types.DetectorModelDefinition
noSmithyDocumentSerde
}
type StartDetectorModelAnalysisOutput struct {
// The ID that you can use to retrieve the analysis result.
AnalysisId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationStartDetectorModelAnalysisMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpStartDetectorModelAnalysis{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpStartDetectorModelAnalysis{}, 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 = addOpStartDetectorModelAnalysisValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opStartDetectorModelAnalysis(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_opStartDetectorModelAnalysis(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "StartDetectorModelAnalysis",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Adds to or modifies the tags of the given resource. Tags are metadata that can
// be used to manage a resource.
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 ARN of the resource.
//
// This member is required.
ResourceArn *string
// The new or modified tags for the resource.
//
// This member is required.
Tags []types.Tag
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: "iotevents",
OperationName: "TagResource",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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"
)
// Removes the given tags (metadata) from the resource.
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 ARN of the resource.
//
// This member is required.
ResourceArn *string
// A list of the keys of the tags to be removed from the resource.
//
// 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: "iotevents",
OperationName: "UntagResource",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Updates an alarm model. Any alarms that were created based on the previous
// version are deleted and then created again as new data arrives.
func (c *Client) UpdateAlarmModel(ctx context.Context, params *UpdateAlarmModelInput, optFns ...func(*Options)) (*UpdateAlarmModelOutput, error) {
if params == nil {
params = &UpdateAlarmModelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateAlarmModel", params, optFns, c.addOperationUpdateAlarmModelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateAlarmModelOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateAlarmModelInput struct {
// The name of the alarm model.
//
// This member is required.
AlarmModelName *string
// Defines when your alarm is invoked.
//
// This member is required.
AlarmRule *types.AlarmRule
// The ARN of the IAM role that allows the alarm to perform actions and access AWS
// resources. For more information, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
// in the AWS General Reference.
//
// This member is required.
RoleArn *string
// Contains the configuration information of alarm state changes.
AlarmCapabilities *types.AlarmCapabilities
// Contains information about one or more alarm actions.
AlarmEventActions *types.AlarmEventActions
// The description of the alarm model.
AlarmModelDescription *string
// Contains information about one or more notification actions.
AlarmNotification *types.AlarmNotification
// A non-negative integer that reflects the severity level of the alarm.
Severity *int32
noSmithyDocumentSerde
}
type UpdateAlarmModelOutput struct {
// The ARN of the alarm model. For more information, see Amazon Resource Names
// (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
// in the AWS General Reference.
AlarmModelArn *string
// The version of the alarm model.
AlarmModelVersion *string
// The time the alarm model was created, in the Unix epoch format.
CreationTime *time.Time
// The time the alarm model was last updated, in the Unix epoch format.
LastUpdateTime *time.Time
// The status of the alarm model. The status can be one of the following values:
// - ACTIVE - The alarm model is active and it's ready to evaluate data.
// - ACTIVATING - AWS IoT Events is activating your alarm model. Activating an
// alarm model can take up to a few minutes.
// - INACTIVE - The alarm model is inactive, so it isn't ready to evaluate data.
// Check your alarm model information and update the alarm model.
// - FAILED - You couldn't create or update the alarm model. Check your alarm
// model information and try again.
Status types.AlarmModelVersionStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateAlarmModelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateAlarmModel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateAlarmModel{}, 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 = addOpUpdateAlarmModelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateAlarmModel(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_opUpdateAlarmModel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "UpdateAlarmModel",
}
}
| 175 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates a detector model. Detectors (instances) spawned by the previous version
// are deleted and then re-created as new inputs arrive.
func (c *Client) UpdateDetectorModel(ctx context.Context, params *UpdateDetectorModelInput, optFns ...func(*Options)) (*UpdateDetectorModelOutput, error) {
if params == nil {
params = &UpdateDetectorModelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateDetectorModel", params, optFns, c.addOperationUpdateDetectorModelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateDetectorModelOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateDetectorModelInput struct {
// Information that defines how a detector operates.
//
// This member is required.
DetectorModelDefinition *types.DetectorModelDefinition
// The name of the detector model that is updated.
//
// This member is required.
DetectorModelName *string
// The ARN of the role that grants permission to AWS IoT Events to perform its
// operations.
//
// This member is required.
RoleArn *string
// A brief description of the detector model.
DetectorModelDescription *string
// Information about the order in which events are evaluated and how actions are
// executed.
EvaluationMethod types.EvaluationMethod
noSmithyDocumentSerde
}
type UpdateDetectorModelOutput struct {
// Information about how the detector model is configured.
DetectorModelConfiguration *types.DetectorModelConfiguration
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateDetectorModelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateDetectorModel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateDetectorModel{}, 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 = addOpUpdateDetectorModelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateDetectorModel(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_opUpdateDetectorModel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "UpdateDetectorModel",
}
}
| 144 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates an input.
func (c *Client) UpdateInput(ctx context.Context, params *UpdateInputInput, optFns ...func(*Options)) (*UpdateInputOutput, error) {
if params == nil {
params = &UpdateInputInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateInput", params, optFns, c.addOperationUpdateInputMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateInputOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateInputInput struct {
// The definition of the input.
//
// This member is required.
InputDefinition *types.InputDefinition
// The name of the input you want to update.
//
// This member is required.
InputName *string
// A brief description of the input.
InputDescription *string
noSmithyDocumentSerde
}
type UpdateInputOutput struct {
// Information about the configuration of the input.
InputConfiguration *types.InputConfiguration
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateInputMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateInput{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateInput{}, 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 = addOpUpdateInputValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateInput(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_opUpdateInput(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "iotevents",
OperationName: "UpdateInput",
}
}
| 133 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
import (
"bytes"
"context"
"encoding/json"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
"github.com/aws/aws-sdk-go-v2/service/iotevents/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"
"io/ioutil"
"strings"
)
type awsRestjson1_deserializeOpCreateAlarmModel struct {
}
func (*awsRestjson1_deserializeOpCreateAlarmModel) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpCreateAlarmModel) 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_deserializeOpErrorCreateAlarmModel(response, &metadata)
}
output := &CreateAlarmModelOutput{}
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_deserializeOpDocumentCreateAlarmModelOutput(&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_deserializeOpErrorCreateAlarmModel(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("LimitExceededException", errorCode):
return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody)
case strings.EqualFold("ResourceAlreadyExistsException", errorCode):
return awsRestjson1_deserializeErrorResourceAlreadyExistsException(response, errorBody)
case strings.EqualFold("ResourceInUseException", errorCode):
return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentCreateAlarmModelOutput(v **CreateAlarmModelOutput, 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 *CreateAlarmModelOutput
if *v == nil {
sv = &CreateAlarmModelOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "alarmModelArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelArn to be of type string, got %T instead", value)
}
sv.AlarmModelArn = ptr.String(jtv)
}
case "alarmModelVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelVersion to be of type string, got %T instead", value)
}
sv.AlarmModelVersion = ptr.String(jtv)
}
case "creationTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "lastUpdateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelVersionStatus to be of type string, got %T instead", value)
}
sv.Status = types.AlarmModelVersionStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpCreateDetectorModel struct {
}
func (*awsRestjson1_deserializeOpCreateDetectorModel) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpCreateDetectorModel) 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_deserializeOpErrorCreateDetectorModel(response, &metadata)
}
output := &CreateDetectorModelOutput{}
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_deserializeOpDocumentCreateDetectorModelOutput(&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_deserializeOpErrorCreateDetectorModel(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("LimitExceededException", errorCode):
return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody)
case strings.EqualFold("ResourceAlreadyExistsException", errorCode):
return awsRestjson1_deserializeErrorResourceAlreadyExistsException(response, errorBody)
case strings.EqualFold("ResourceInUseException", errorCode):
return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentCreateDetectorModelOutput(v **CreateDetectorModelOutput, 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 *CreateDetectorModelOutput
if *v == nil {
sv = &CreateDetectorModelOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "detectorModelConfiguration":
if err := awsRestjson1_deserializeDocumentDetectorModelConfiguration(&sv.DetectorModelConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpCreateInput struct {
}
func (*awsRestjson1_deserializeOpCreateInput) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpCreateInput) 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_deserializeOpErrorCreateInput(response, &metadata)
}
output := &CreateInputOutput{}
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_deserializeOpDocumentCreateInputOutput(&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_deserializeOpErrorCreateInput(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceAlreadyExistsException", errorCode):
return awsRestjson1_deserializeErrorResourceAlreadyExistsException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentCreateInputOutput(v **CreateInputOutput, 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 *CreateInputOutput
if *v == nil {
sv = &CreateInputOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "inputConfiguration":
if err := awsRestjson1_deserializeDocumentInputConfiguration(&sv.InputConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDeleteAlarmModel struct {
}
func (*awsRestjson1_deserializeOpDeleteAlarmModel) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeleteAlarmModel) 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_deserializeOpErrorDeleteAlarmModel(response, &metadata)
}
output := &DeleteAlarmModelOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDeleteAlarmModel(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceInUseException", errorCode):
return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpDeleteDetectorModel struct {
}
func (*awsRestjson1_deserializeOpDeleteDetectorModel) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeleteDetectorModel) 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_deserializeOpErrorDeleteDetectorModel(response, &metadata)
}
output := &DeleteDetectorModelOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDeleteDetectorModel(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceInUseException", errorCode):
return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpDeleteInput struct {
}
func (*awsRestjson1_deserializeOpDeleteInput) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeleteInput) 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_deserializeOpErrorDeleteInput(response, &metadata)
}
output := &DeleteInputOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDeleteInput(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceInUseException", errorCode):
return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpDescribeAlarmModel struct {
}
func (*awsRestjson1_deserializeOpDescribeAlarmModel) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDescribeAlarmModel) 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_deserializeOpErrorDescribeAlarmModel(response, &metadata)
}
output := &DescribeAlarmModelOutput{}
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_deserializeOpDocumentDescribeAlarmModelOutput(&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_deserializeOpErrorDescribeAlarmModel(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDescribeAlarmModelOutput(v **DescribeAlarmModelOutput, 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 *DescribeAlarmModelOutput
if *v == nil {
sv = &DescribeAlarmModelOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "alarmCapabilities":
if err := awsRestjson1_deserializeDocumentAlarmCapabilities(&sv.AlarmCapabilities, value); err != nil {
return err
}
case "alarmEventActions":
if err := awsRestjson1_deserializeDocumentAlarmEventActions(&sv.AlarmEventActions, value); err != nil {
return err
}
case "alarmModelArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelArn to be of type string, got %T instead", value)
}
sv.AlarmModelArn = ptr.String(jtv)
}
case "alarmModelDescription":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelDescription to be of type string, got %T instead", value)
}
sv.AlarmModelDescription = ptr.String(jtv)
}
case "alarmModelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelName to be of type string, got %T instead", value)
}
sv.AlarmModelName = ptr.String(jtv)
}
case "alarmModelVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelVersion to be of type string, got %T instead", value)
}
sv.AlarmModelVersion = ptr.String(jtv)
}
case "alarmNotification":
if err := awsRestjson1_deserializeDocumentAlarmNotification(&sv.AlarmNotification, value); err != nil {
return err
}
case "alarmRule":
if err := awsRestjson1_deserializeDocumentAlarmRule(&sv.AlarmRule, value); err != nil {
return err
}
case "creationTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "key":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AttributeJsonPath to be of type string, got %T instead", value)
}
sv.Key = ptr.String(jtv)
}
case "lastUpdateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "roleArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value)
}
sv.RoleArn = ptr.String(jtv)
}
case "severity":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Severity to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Severity = ptr.Int32(int32(i64))
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelVersionStatus to be of type string, got %T instead", value)
}
sv.Status = types.AlarmModelVersionStatus(jtv)
}
case "statusMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value)
}
sv.StatusMessage = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDescribeDetectorModel struct {
}
func (*awsRestjson1_deserializeOpDescribeDetectorModel) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDescribeDetectorModel) 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_deserializeOpErrorDescribeDetectorModel(response, &metadata)
}
output := &DescribeDetectorModelOutput{}
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_deserializeOpDocumentDescribeDetectorModelOutput(&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_deserializeOpErrorDescribeDetectorModel(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDescribeDetectorModelOutput(v **DescribeDetectorModelOutput, 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 *DescribeDetectorModelOutput
if *v == nil {
sv = &DescribeDetectorModelOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "detectorModel":
if err := awsRestjson1_deserializeDocumentDetectorModel(&sv.DetectorModel, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDescribeDetectorModelAnalysis struct {
}
func (*awsRestjson1_deserializeOpDescribeDetectorModelAnalysis) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDescribeDetectorModelAnalysis) 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_deserializeOpErrorDescribeDetectorModelAnalysis(response, &metadata)
}
output := &DescribeDetectorModelAnalysisOutput{}
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_deserializeOpDocumentDescribeDetectorModelAnalysisOutput(&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_deserializeOpErrorDescribeDetectorModelAnalysis(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDescribeDetectorModelAnalysisOutput(v **DescribeDetectorModelAnalysisOutput, 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 *DescribeDetectorModelAnalysisOutput
if *v == nil {
sv = &DescribeDetectorModelAnalysisOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AnalysisStatus to be of type string, got %T instead", value)
}
sv.Status = types.AnalysisStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDescribeInput struct {
}
func (*awsRestjson1_deserializeOpDescribeInput) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDescribeInput) 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_deserializeOpErrorDescribeInput(response, &metadata)
}
output := &DescribeInputOutput{}
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_deserializeOpDocumentDescribeInputOutput(&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_deserializeOpErrorDescribeInput(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDescribeInputOutput(v **DescribeInputOutput, 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 *DescribeInputOutput
if *v == nil {
sv = &DescribeInputOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "input":
if err := awsRestjson1_deserializeDocumentInput(&sv.Input, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDescribeLoggingOptions struct {
}
func (*awsRestjson1_deserializeOpDescribeLoggingOptions) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDescribeLoggingOptions) 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_deserializeOpErrorDescribeLoggingOptions(response, &metadata)
}
output := &DescribeLoggingOptionsOutput{}
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_deserializeOpDocumentDescribeLoggingOptionsOutput(&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_deserializeOpErrorDescribeLoggingOptions(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("UnsupportedOperationException", errorCode):
return awsRestjson1_deserializeErrorUnsupportedOperationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDescribeLoggingOptionsOutput(v **DescribeLoggingOptionsOutput, 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 *DescribeLoggingOptionsOutput
if *v == nil {
sv = &DescribeLoggingOptionsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "loggingOptions":
if err := awsRestjson1_deserializeDocumentLoggingOptions(&sv.LoggingOptions, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetDetectorModelAnalysisResults struct {
}
func (*awsRestjson1_deserializeOpGetDetectorModelAnalysisResults) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetDetectorModelAnalysisResults) 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_deserializeOpErrorGetDetectorModelAnalysisResults(response, &metadata)
}
output := &GetDetectorModelAnalysisResultsOutput{}
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_deserializeOpDocumentGetDetectorModelAnalysisResultsOutput(&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_deserializeOpErrorGetDetectorModelAnalysisResults(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetDetectorModelAnalysisResultsOutput(v **GetDetectorModelAnalysisResultsOutput, 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 *GetDetectorModelAnalysisResultsOutput
if *v == nil {
sv = &GetDetectorModelAnalysisResultsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "analysisResults":
if err := awsRestjson1_deserializeDocumentAnalysisResults(&sv.AnalysisResults, 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_deserializeOpListAlarmModels struct {
}
func (*awsRestjson1_deserializeOpListAlarmModels) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListAlarmModels) 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_deserializeOpErrorListAlarmModels(response, &metadata)
}
output := &ListAlarmModelsOutput{}
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_deserializeOpDocumentListAlarmModelsOutput(&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_deserializeOpErrorListAlarmModels(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListAlarmModelsOutput(v **ListAlarmModelsOutput, 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 *ListAlarmModelsOutput
if *v == nil {
sv = &ListAlarmModelsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "alarmModelSummaries":
if err := awsRestjson1_deserializeDocumentAlarmModelSummaries(&sv.AlarmModelSummaries, 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_deserializeOpListAlarmModelVersions struct {
}
func (*awsRestjson1_deserializeOpListAlarmModelVersions) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListAlarmModelVersions) 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_deserializeOpErrorListAlarmModelVersions(response, &metadata)
}
output := &ListAlarmModelVersionsOutput{}
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_deserializeOpDocumentListAlarmModelVersionsOutput(&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_deserializeOpErrorListAlarmModelVersions(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListAlarmModelVersionsOutput(v **ListAlarmModelVersionsOutput, 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 *ListAlarmModelVersionsOutput
if *v == nil {
sv = &ListAlarmModelVersionsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "alarmModelVersionSummaries":
if err := awsRestjson1_deserializeDocumentAlarmModelVersionSummaries(&sv.AlarmModelVersionSummaries, 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_deserializeOpListDetectorModels struct {
}
func (*awsRestjson1_deserializeOpListDetectorModels) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListDetectorModels) 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_deserializeOpErrorListDetectorModels(response, &metadata)
}
output := &ListDetectorModelsOutput{}
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_deserializeOpDocumentListDetectorModelsOutput(&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_deserializeOpErrorListDetectorModels(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListDetectorModelsOutput(v **ListDetectorModelsOutput, 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 *ListDetectorModelsOutput
if *v == nil {
sv = &ListDetectorModelsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "detectorModelSummaries":
if err := awsRestjson1_deserializeDocumentDetectorModelSummaries(&sv.DetectorModelSummaries, 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_deserializeOpListDetectorModelVersions struct {
}
func (*awsRestjson1_deserializeOpListDetectorModelVersions) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListDetectorModelVersions) 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_deserializeOpErrorListDetectorModelVersions(response, &metadata)
}
output := &ListDetectorModelVersionsOutput{}
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_deserializeOpDocumentListDetectorModelVersionsOutput(&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_deserializeOpErrorListDetectorModelVersions(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListDetectorModelVersionsOutput(v **ListDetectorModelVersionsOutput, 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 *ListDetectorModelVersionsOutput
if *v == nil {
sv = &ListDetectorModelVersionsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "detectorModelVersionSummaries":
if err := awsRestjson1_deserializeDocumentDetectorModelVersionSummaries(&sv.DetectorModelVersionSummaries, 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_deserializeOpListInputRoutings struct {
}
func (*awsRestjson1_deserializeOpListInputRoutings) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListInputRoutings) 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_deserializeOpErrorListInputRoutings(response, &metadata)
}
output := &ListInputRoutingsOutput{}
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_deserializeOpDocumentListInputRoutingsOutput(&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_deserializeOpErrorListInputRoutings(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListInputRoutingsOutput(v **ListInputRoutingsOutput, 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 *ListInputRoutingsOutput
if *v == nil {
sv = &ListInputRoutingsOutput{}
} 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 "routedResources":
if err := awsRestjson1_deserializeDocumentRoutedResources(&sv.RoutedResources, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListInputs struct {
}
func (*awsRestjson1_deserializeOpListInputs) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListInputs) 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_deserializeOpErrorListInputs(response, &metadata)
}
output := &ListInputsOutput{}
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_deserializeOpDocumentListInputsOutput(&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_deserializeOpErrorListInputs(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListInputsOutput(v **ListInputsOutput, 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 *ListInputsOutput
if *v == nil {
sv = &ListInputsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "inputSummaries":
if err := awsRestjson1_deserializeDocumentInputSummaries(&sv.InputSummaries, 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_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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceInUseException", errorCode):
return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(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_deserializeOpPutLoggingOptions struct {
}
func (*awsRestjson1_deserializeOpPutLoggingOptions) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpPutLoggingOptions) 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_deserializeOpErrorPutLoggingOptions(response, &metadata)
}
output := &PutLoggingOptionsOutput{}
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_deserializeOpErrorPutLoggingOptions(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceInUseException", errorCode):
return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("UnsupportedOperationException", errorCode):
return awsRestjson1_deserializeErrorUnsupportedOperationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpStartDetectorModelAnalysis struct {
}
func (*awsRestjson1_deserializeOpStartDetectorModelAnalysis) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpStartDetectorModelAnalysis) 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_deserializeOpErrorStartDetectorModelAnalysis(response, &metadata)
}
output := &StartDetectorModelAnalysisOutput{}
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_deserializeOpDocumentStartDetectorModelAnalysisOutput(&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_deserializeOpErrorStartDetectorModelAnalysis(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("LimitExceededException", errorCode):
return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentStartDetectorModelAnalysisOutput(v **StartDetectorModelAnalysisOutput, 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 *StartDetectorModelAnalysisOutput
if *v == nil {
sv = &StartDetectorModelAnalysisOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "analysisId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AnalysisId to be of type string, got %T instead", value)
}
sv.AnalysisId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("LimitExceededException", errorCode):
return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody)
case strings.EqualFold("ResourceInUseException", errorCode):
return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceInUseException", errorCode):
return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpUpdateAlarmModel struct {
}
func (*awsRestjson1_deserializeOpUpdateAlarmModel) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateAlarmModel) 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_deserializeOpErrorUpdateAlarmModel(response, &metadata)
}
output := &UpdateAlarmModelOutput{}
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_deserializeOpDocumentUpdateAlarmModelOutput(&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_deserializeOpErrorUpdateAlarmModel(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceInUseException", errorCode):
return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentUpdateAlarmModelOutput(v **UpdateAlarmModelOutput, 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 *UpdateAlarmModelOutput
if *v == nil {
sv = &UpdateAlarmModelOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "alarmModelArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelArn to be of type string, got %T instead", value)
}
sv.AlarmModelArn = ptr.String(jtv)
}
case "alarmModelVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelVersion to be of type string, got %T instead", value)
}
sv.AlarmModelVersion = ptr.String(jtv)
}
case "creationTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "lastUpdateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelVersionStatus to be of type string, got %T instead", value)
}
sv.Status = types.AlarmModelVersionStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpUpdateDetectorModel struct {
}
func (*awsRestjson1_deserializeOpUpdateDetectorModel) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateDetectorModel) 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_deserializeOpErrorUpdateDetectorModel(response, &metadata)
}
output := &UpdateDetectorModelOutput{}
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_deserializeOpDocumentUpdateDetectorModelOutput(&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_deserializeOpErrorUpdateDetectorModel(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceInUseException", errorCode):
return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentUpdateDetectorModelOutput(v **UpdateDetectorModelOutput, 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 *UpdateDetectorModelOutput
if *v == nil {
sv = &UpdateDetectorModelOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "detectorModelConfiguration":
if err := awsRestjson1_deserializeDocumentDetectorModelConfiguration(&sv.DetectorModelConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpUpdateInput struct {
}
func (*awsRestjson1_deserializeOpUpdateInput) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateInput) 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_deserializeOpErrorUpdateInput(response, &metadata)
}
output := &UpdateInputOutput{}
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_deserializeOpDocumentUpdateInputOutput(&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_deserializeOpErrorUpdateInput(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceInUseException", errorCode):
return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentUpdateInputOutput(v **UpdateInputOutput, 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 *UpdateInputOutput
if *v == nil {
sv = &UpdateInputOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "inputConfiguration":
if err := awsRestjson1_deserializeDocumentInputConfiguration(&sv.InputConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeErrorInternalFailureException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.InternalFailureException{}
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_deserializeDocumentInternalFailureException(&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_deserializeErrorInvalidRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.InvalidRequestException{}
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_deserializeDocumentInvalidRequestException(&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_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.LimitExceededException{}
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_deserializeDocumentLimitExceededException(&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_deserializeErrorResourceAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ResourceAlreadyExistsException{}
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_deserializeDocumentResourceAlreadyExistsException(&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_deserializeErrorResourceInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ResourceInUseException{}
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_deserializeDocumentResourceInUseException(&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_deserializeErrorServiceUnavailableException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ServiceUnavailableException{}
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_deserializeDocumentServiceUnavailableException(&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_deserializeErrorUnsupportedOperationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.UnsupportedOperationException{}
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_deserializeDocumentUnsupportedOperationException(&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_deserializeDocumentAcknowledgeFlow(v **types.AcknowledgeFlow, 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.AcknowledgeFlow
if *v == nil {
sv = &types.AcknowledgeFlow{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "enabled":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected AcknowledgeFlowEnabled to be of type *bool, got %T instead", value)
}
sv.Enabled = ptr.Bool(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAction(v **types.Action, 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.Action
if *v == nil {
sv = &types.Action{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "clearTimer":
if err := awsRestjson1_deserializeDocumentClearTimerAction(&sv.ClearTimer, value); err != nil {
return err
}
case "dynamoDB":
if err := awsRestjson1_deserializeDocumentDynamoDBAction(&sv.DynamoDB, value); err != nil {
return err
}
case "dynamoDBv2":
if err := awsRestjson1_deserializeDocumentDynamoDBv2Action(&sv.DynamoDBv2, value); err != nil {
return err
}
case "firehose":
if err := awsRestjson1_deserializeDocumentFirehoseAction(&sv.Firehose, value); err != nil {
return err
}
case "iotEvents":
if err := awsRestjson1_deserializeDocumentIotEventsAction(&sv.IotEvents, value); err != nil {
return err
}
case "iotSiteWise":
if err := awsRestjson1_deserializeDocumentIotSiteWiseAction(&sv.IotSiteWise, value); err != nil {
return err
}
case "iotTopicPublish":
if err := awsRestjson1_deserializeDocumentIotTopicPublishAction(&sv.IotTopicPublish, value); err != nil {
return err
}
case "lambda":
if err := awsRestjson1_deserializeDocumentLambdaAction(&sv.Lambda, value); err != nil {
return err
}
case "resetTimer":
if err := awsRestjson1_deserializeDocumentResetTimerAction(&sv.ResetTimer, value); err != nil {
return err
}
case "setTimer":
if err := awsRestjson1_deserializeDocumentSetTimerAction(&sv.SetTimer, value); err != nil {
return err
}
case "setVariable":
if err := awsRestjson1_deserializeDocumentSetVariableAction(&sv.SetVariable, value); err != nil {
return err
}
case "sns":
if err := awsRestjson1_deserializeDocumentSNSTopicPublishAction(&sv.Sns, value); err != nil {
return err
}
case "sqs":
if err := awsRestjson1_deserializeDocumentSqsAction(&sv.Sqs, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentActions(v *[]types.Action, 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.Action
if *v == nil {
cv = []types.Action{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Action
destAddr := &col
if err := awsRestjson1_deserializeDocumentAction(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentAlarmAction(v **types.AlarmAction, 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.AlarmAction
if *v == nil {
sv = &types.AlarmAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "dynamoDB":
if err := awsRestjson1_deserializeDocumentDynamoDBAction(&sv.DynamoDB, value); err != nil {
return err
}
case "dynamoDBv2":
if err := awsRestjson1_deserializeDocumentDynamoDBv2Action(&sv.DynamoDBv2, value); err != nil {
return err
}
case "firehose":
if err := awsRestjson1_deserializeDocumentFirehoseAction(&sv.Firehose, value); err != nil {
return err
}
case "iotEvents":
if err := awsRestjson1_deserializeDocumentIotEventsAction(&sv.IotEvents, value); err != nil {
return err
}
case "iotSiteWise":
if err := awsRestjson1_deserializeDocumentIotSiteWiseAction(&sv.IotSiteWise, value); err != nil {
return err
}
case "iotTopicPublish":
if err := awsRestjson1_deserializeDocumentIotTopicPublishAction(&sv.IotTopicPublish, value); err != nil {
return err
}
case "lambda":
if err := awsRestjson1_deserializeDocumentLambdaAction(&sv.Lambda, value); err != nil {
return err
}
case "sns":
if err := awsRestjson1_deserializeDocumentSNSTopicPublishAction(&sv.Sns, value); err != nil {
return err
}
case "sqs":
if err := awsRestjson1_deserializeDocumentSqsAction(&sv.Sqs, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAlarmActions(v *[]types.AlarmAction, 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.AlarmAction
if *v == nil {
cv = []types.AlarmAction{}
} else {
cv = *v
}
for _, value := range shape {
var col types.AlarmAction
destAddr := &col
if err := awsRestjson1_deserializeDocumentAlarmAction(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentAlarmCapabilities(v **types.AlarmCapabilities, 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.AlarmCapabilities
if *v == nil {
sv = &types.AlarmCapabilities{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "acknowledgeFlow":
if err := awsRestjson1_deserializeDocumentAcknowledgeFlow(&sv.AcknowledgeFlow, value); err != nil {
return err
}
case "initializationConfiguration":
if err := awsRestjson1_deserializeDocumentInitializationConfiguration(&sv.InitializationConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAlarmEventActions(v **types.AlarmEventActions, 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.AlarmEventActions
if *v == nil {
sv = &types.AlarmEventActions{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "alarmActions":
if err := awsRestjson1_deserializeDocumentAlarmActions(&sv.AlarmActions, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAlarmModelSummaries(v *[]types.AlarmModelSummary, 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.AlarmModelSummary
if *v == nil {
cv = []types.AlarmModelSummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.AlarmModelSummary
destAddr := &col
if err := awsRestjson1_deserializeDocumentAlarmModelSummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentAlarmModelSummary(v **types.AlarmModelSummary, 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.AlarmModelSummary
if *v == nil {
sv = &types.AlarmModelSummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "alarmModelDescription":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelDescription to be of type string, got %T instead", value)
}
sv.AlarmModelDescription = ptr.String(jtv)
}
case "alarmModelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelName to be of type string, got %T instead", value)
}
sv.AlarmModelName = ptr.String(jtv)
}
case "creationTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAlarmModelVersionSummaries(v *[]types.AlarmModelVersionSummary, 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.AlarmModelVersionSummary
if *v == nil {
cv = []types.AlarmModelVersionSummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.AlarmModelVersionSummary
destAddr := &col
if err := awsRestjson1_deserializeDocumentAlarmModelVersionSummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentAlarmModelVersionSummary(v **types.AlarmModelVersionSummary, 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.AlarmModelVersionSummary
if *v == nil {
sv = &types.AlarmModelVersionSummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "alarmModelArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelArn to be of type string, got %T instead", value)
}
sv.AlarmModelArn = ptr.String(jtv)
}
case "alarmModelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelName to be of type string, got %T instead", value)
}
sv.AlarmModelName = ptr.String(jtv)
}
case "alarmModelVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelVersion to be of type string, got %T instead", value)
}
sv.AlarmModelVersion = ptr.String(jtv)
}
case "creationTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "lastUpdateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "roleArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value)
}
sv.RoleArn = ptr.String(jtv)
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelVersionStatus to be of type string, got %T instead", value)
}
sv.Status = types.AlarmModelVersionStatus(jtv)
}
case "statusMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value)
}
sv.StatusMessage = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAlarmNotification(v **types.AlarmNotification, 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.AlarmNotification
if *v == nil {
sv = &types.AlarmNotification{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "notificationActions":
if err := awsRestjson1_deserializeDocumentNotificationActions(&sv.NotificationActions, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAlarmRule(v **types.AlarmRule, 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.AlarmRule
if *v == nil {
sv = &types.AlarmRule{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "simpleRule":
if err := awsRestjson1_deserializeDocumentSimpleRule(&sv.SimpleRule, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAnalysisResult(v **types.AnalysisResult, 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.AnalysisResult
if *v == nil {
sv = &types.AnalysisResult{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "level":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AnalysisResultLevel to be of type string, got %T instead", value)
}
sv.Level = types.AnalysisResultLevel(jtv)
}
case "locations":
if err := awsRestjson1_deserializeDocumentAnalysisResultLocations(&sv.Locations, value); err != nil {
return err
}
case "message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AnalysisMessage 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 AnalysisType to be of type string, got %T instead", value)
}
sv.Type = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAnalysisResultLocation(v **types.AnalysisResultLocation, 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.AnalysisResultLocation
if *v == nil {
sv = &types.AnalysisResultLocation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "path":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AnalysisResultLocationPath to be of type string, got %T instead", value)
}
sv.Path = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAnalysisResultLocations(v *[]types.AnalysisResultLocation, 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.AnalysisResultLocation
if *v == nil {
cv = []types.AnalysisResultLocation{}
} else {
cv = *v
}
for _, value := range shape {
var col types.AnalysisResultLocation
destAddr := &col
if err := awsRestjson1_deserializeDocumentAnalysisResultLocation(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentAnalysisResults(v *[]types.AnalysisResult, 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.AnalysisResult
if *v == nil {
cv = []types.AnalysisResult{}
} else {
cv = *v
}
for _, value := range shape {
var col types.AnalysisResult
destAddr := &col
if err := awsRestjson1_deserializeDocumentAnalysisResult(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentAssetPropertyTimestamp(v **types.AssetPropertyTimestamp, 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.AssetPropertyTimestamp
if *v == nil {
sv = &types.AssetPropertyTimestamp{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "offsetInNanos":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AssetPropertyOffsetInNanos to be of type string, got %T instead", value)
}
sv.OffsetInNanos = ptr.String(jtv)
}
case "timeInSeconds":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AssetPropertyTimeInSeconds to be of type string, got %T instead", value)
}
sv.TimeInSeconds = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAssetPropertyValue(v **types.AssetPropertyValue, 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.AssetPropertyValue
if *v == nil {
sv = &types.AssetPropertyValue{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "quality":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AssetPropertyQuality to be of type string, got %T instead", value)
}
sv.Quality = ptr.String(jtv)
}
case "timestamp":
if err := awsRestjson1_deserializeDocumentAssetPropertyTimestamp(&sv.Timestamp, value); err != nil {
return err
}
case "value":
if err := awsRestjson1_deserializeDocumentAssetPropertyVariant(&sv.Value, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAssetPropertyVariant(v **types.AssetPropertyVariant, 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.AssetPropertyVariant
if *v == nil {
sv = &types.AssetPropertyVariant{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "booleanValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AssetPropertyBooleanValue to be of type string, got %T instead", value)
}
sv.BooleanValue = ptr.String(jtv)
}
case "doubleValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AssetPropertyDoubleValue to be of type string, got %T instead", value)
}
sv.DoubleValue = ptr.String(jtv)
}
case "integerValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AssetPropertyIntegerValue to be of type string, got %T instead", value)
}
sv.IntegerValue = ptr.String(jtv)
}
case "stringValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AssetPropertyStringValue to be of type string, got %T instead", value)
}
sv.StringValue = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAttribute(v **types.Attribute, 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.Attribute
if *v == nil {
sv = &types.Attribute{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "jsonPath":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AttributeJsonPath to be of type string, got %T instead", value)
}
sv.JsonPath = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAttributes(v *[]types.Attribute, 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.Attribute
if *v == nil {
cv = []types.Attribute{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Attribute
destAddr := &col
if err := awsRestjson1_deserializeDocumentAttribute(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentClearTimerAction(v **types.ClearTimerAction, 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.ClearTimerAction
if *v == nil {
sv = &types.ClearTimerAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "timerName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TimerName to be of type string, got %T instead", value)
}
sv.TimerName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDetectorDebugOption(v **types.DetectorDebugOption, 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.DetectorDebugOption
if *v == nil {
sv = &types.DetectorDebugOption{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "detectorModelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DetectorModelName to be of type string, got %T instead", value)
}
sv.DetectorModelName = ptr.String(jtv)
}
case "keyValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyValue to be of type string, got %T instead", value)
}
sv.KeyValue = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDetectorDebugOptions(v *[]types.DetectorDebugOption, 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.DetectorDebugOption
if *v == nil {
cv = []types.DetectorDebugOption{}
} else {
cv = *v
}
for _, value := range shape {
var col types.DetectorDebugOption
destAddr := &col
if err := awsRestjson1_deserializeDocumentDetectorDebugOption(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentDetectorModel(v **types.DetectorModel, 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.DetectorModel
if *v == nil {
sv = &types.DetectorModel{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "detectorModelConfiguration":
if err := awsRestjson1_deserializeDocumentDetectorModelConfiguration(&sv.DetectorModelConfiguration, value); err != nil {
return err
}
case "detectorModelDefinition":
if err := awsRestjson1_deserializeDocumentDetectorModelDefinition(&sv.DetectorModelDefinition, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDetectorModelConfiguration(v **types.DetectorModelConfiguration, 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.DetectorModelConfiguration
if *v == nil {
sv = &types.DetectorModelConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "creationTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "detectorModelArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DetectorModelArn to be of type string, got %T instead", value)
}
sv.DetectorModelArn = ptr.String(jtv)
}
case "detectorModelDescription":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DetectorModelDescription to be of type string, got %T instead", value)
}
sv.DetectorModelDescription = ptr.String(jtv)
}
case "detectorModelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DetectorModelName to be of type string, got %T instead", value)
}
sv.DetectorModelName = ptr.String(jtv)
}
case "detectorModelVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DetectorModelVersion to be of type string, got %T instead", value)
}
sv.DetectorModelVersion = ptr.String(jtv)
}
case "evaluationMethod":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EvaluationMethod to be of type string, got %T instead", value)
}
sv.EvaluationMethod = types.EvaluationMethod(jtv)
}
case "key":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AttributeJsonPath to be of type string, got %T instead", value)
}
sv.Key = ptr.String(jtv)
}
case "lastUpdateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "roleArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value)
}
sv.RoleArn = ptr.String(jtv)
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DetectorModelVersionStatus to be of type string, got %T instead", value)
}
sv.Status = types.DetectorModelVersionStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDetectorModelDefinition(v **types.DetectorModelDefinition, 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.DetectorModelDefinition
if *v == nil {
sv = &types.DetectorModelDefinition{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "initialStateName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected StateName to be of type string, got %T instead", value)
}
sv.InitialStateName = ptr.String(jtv)
}
case "states":
if err := awsRestjson1_deserializeDocumentStates(&sv.States, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDetectorModelSummaries(v *[]types.DetectorModelSummary, 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.DetectorModelSummary
if *v == nil {
cv = []types.DetectorModelSummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.DetectorModelSummary
destAddr := &col
if err := awsRestjson1_deserializeDocumentDetectorModelSummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentDetectorModelSummary(v **types.DetectorModelSummary, 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.DetectorModelSummary
if *v == nil {
sv = &types.DetectorModelSummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "creationTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "detectorModelDescription":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DetectorModelDescription to be of type string, got %T instead", value)
}
sv.DetectorModelDescription = ptr.String(jtv)
}
case "detectorModelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DetectorModelName to be of type string, got %T instead", value)
}
sv.DetectorModelName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDetectorModelVersionSummaries(v *[]types.DetectorModelVersionSummary, 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.DetectorModelVersionSummary
if *v == nil {
cv = []types.DetectorModelVersionSummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.DetectorModelVersionSummary
destAddr := &col
if err := awsRestjson1_deserializeDocumentDetectorModelVersionSummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentDetectorModelVersionSummary(v **types.DetectorModelVersionSummary, 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.DetectorModelVersionSummary
if *v == nil {
sv = &types.DetectorModelVersionSummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "creationTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "detectorModelArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DetectorModelArn to be of type string, got %T instead", value)
}
sv.DetectorModelArn = ptr.String(jtv)
}
case "detectorModelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DetectorModelName to be of type string, got %T instead", value)
}
sv.DetectorModelName = ptr.String(jtv)
}
case "detectorModelVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DetectorModelVersion to be of type string, got %T instead", value)
}
sv.DetectorModelVersion = ptr.String(jtv)
}
case "evaluationMethod":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EvaluationMethod to be of type string, got %T instead", value)
}
sv.EvaluationMethod = types.EvaluationMethod(jtv)
}
case "lastUpdateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "roleArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value)
}
sv.RoleArn = ptr.String(jtv)
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DetectorModelVersionStatus to be of type string, got %T instead", value)
}
sv.Status = types.DetectorModelVersionStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDynamoDBAction(v **types.DynamoDBAction, 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.DynamoDBAction
if *v == nil {
sv = &types.DynamoDBAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "hashKeyField":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DynamoKeyField to be of type string, got %T instead", value)
}
sv.HashKeyField = ptr.String(jtv)
}
case "hashKeyType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DynamoKeyType to be of type string, got %T instead", value)
}
sv.HashKeyType = ptr.String(jtv)
}
case "hashKeyValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DynamoKeyValue to be of type string, got %T instead", value)
}
sv.HashKeyValue = ptr.String(jtv)
}
case "operation":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DynamoOperation to be of type string, got %T instead", value)
}
sv.Operation = ptr.String(jtv)
}
case "payload":
if err := awsRestjson1_deserializeDocumentPayload(&sv.Payload, value); err != nil {
return err
}
case "payloadField":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DynamoKeyField to be of type string, got %T instead", value)
}
sv.PayloadField = ptr.String(jtv)
}
case "rangeKeyField":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DynamoKeyField to be of type string, got %T instead", value)
}
sv.RangeKeyField = ptr.String(jtv)
}
case "rangeKeyType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DynamoKeyType to be of type string, got %T instead", value)
}
sv.RangeKeyType = ptr.String(jtv)
}
case "rangeKeyValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DynamoKeyValue to be of type string, got %T instead", value)
}
sv.RangeKeyValue = ptr.String(jtv)
}
case "tableName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DynamoTableName to be of type string, got %T instead", value)
}
sv.TableName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDynamoDBv2Action(v **types.DynamoDBv2Action, 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.DynamoDBv2Action
if *v == nil {
sv = &types.DynamoDBv2Action{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "payload":
if err := awsRestjson1_deserializeDocumentPayload(&sv.Payload, value); err != nil {
return err
}
case "tableName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DynamoTableName to be of type string, got %T instead", value)
}
sv.TableName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentEmailConfiguration(v **types.EmailConfiguration, 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.EmailConfiguration
if *v == nil {
sv = &types.EmailConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "content":
if err := awsRestjson1_deserializeDocumentEmailContent(&sv.Content, value); err != nil {
return err
}
case "from":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FromEmail to be of type string, got %T instead", value)
}
sv.From = ptr.String(jtv)
}
case "recipients":
if err := awsRestjson1_deserializeDocumentEmailRecipients(&sv.Recipients, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentEmailConfigurations(v *[]types.EmailConfiguration, 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.EmailConfiguration
if *v == nil {
cv = []types.EmailConfiguration{}
} else {
cv = *v
}
for _, value := range shape {
var col types.EmailConfiguration
destAddr := &col
if err := awsRestjson1_deserializeDocumentEmailConfiguration(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentEmailContent(v **types.EmailContent, 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.EmailContent
if *v == nil {
sv = &types.EmailContent{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "additionalMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NotificationAdditionalMessage to be of type string, got %T instead", value)
}
sv.AdditionalMessage = ptr.String(jtv)
}
case "subject":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EmailSubject to be of type string, got %T instead", value)
}
sv.Subject = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentEmailRecipients(v **types.EmailRecipients, 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.EmailRecipients
if *v == nil {
sv = &types.EmailRecipients{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "to":
if err := awsRestjson1_deserializeDocumentRecipientDetails(&sv.To, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentEvent(v **types.Event, 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.Event
if *v == nil {
sv = &types.Event{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "actions":
if err := awsRestjson1_deserializeDocumentActions(&sv.Actions, value); err != nil {
return err
}
case "condition":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Condition to be of type string, got %T instead", value)
}
sv.Condition = ptr.String(jtv)
}
case "eventName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EventName to be of type string, got %T instead", value)
}
sv.EventName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentEvents(v *[]types.Event, 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.Event
if *v == nil {
cv = []types.Event{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Event
destAddr := &col
if err := awsRestjson1_deserializeDocumentEvent(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentFirehoseAction(v **types.FirehoseAction, 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.FirehoseAction
if *v == nil {
sv = &types.FirehoseAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "deliveryStreamName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DeliveryStreamName to be of type string, got %T instead", value)
}
sv.DeliveryStreamName = ptr.String(jtv)
}
case "payload":
if err := awsRestjson1_deserializeDocumentPayload(&sv.Payload, value); err != nil {
return err
}
case "separator":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FirehoseSeparator to be of type string, got %T instead", value)
}
sv.Separator = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentInitializationConfiguration(v **types.InitializationConfiguration, 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.InitializationConfiguration
if *v == nil {
sv = &types.InitializationConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "disabledOnInitialization":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected DisabledOnInitialization to be of type *bool, got %T instead", value)
}
sv.DisabledOnInitialization = ptr.Bool(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentInput(v **types.Input, 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.Input
if *v == nil {
sv = &types.Input{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "inputConfiguration":
if err := awsRestjson1_deserializeDocumentInputConfiguration(&sv.InputConfiguration, value); err != nil {
return err
}
case "inputDefinition":
if err := awsRestjson1_deserializeDocumentInputDefinition(&sv.InputDefinition, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentInputConfiguration(v **types.InputConfiguration, 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.InputConfiguration
if *v == nil {
sv = &types.InputConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "creationTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "inputArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected InputArn to be of type string, got %T instead", value)
}
sv.InputArn = ptr.String(jtv)
}
case "inputDescription":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected InputDescription to be of type string, got %T instead", value)
}
sv.InputDescription = ptr.String(jtv)
}
case "inputName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected InputName to be of type string, got %T instead", value)
}
sv.InputName = ptr.String(jtv)
}
case "lastUpdateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected InputStatus to be of type string, got %T instead", value)
}
sv.Status = types.InputStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentInputDefinition(v **types.InputDefinition, 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.InputDefinition
if *v == nil {
sv = &types.InputDefinition{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "attributes":
if err := awsRestjson1_deserializeDocumentAttributes(&sv.Attributes, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentInputSummaries(v *[]types.InputSummary, 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.InputSummary
if *v == nil {
cv = []types.InputSummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.InputSummary
destAddr := &col
if err := awsRestjson1_deserializeDocumentInputSummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentInputSummary(v **types.InputSummary, 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.InputSummary
if *v == nil {
sv = &types.InputSummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "creationTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "inputArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected InputArn to be of type string, got %T instead", value)
}
sv.InputArn = ptr.String(jtv)
}
case "inputDescription":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected InputDescription to be of type string, got %T instead", value)
}
sv.InputDescription = ptr.String(jtv)
}
case "inputName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected InputName to be of type string, got %T instead", value)
}
sv.InputName = ptr.String(jtv)
}
case "lastUpdateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected InputStatus to be of type string, got %T instead", value)
}
sv.Status = types.InputStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentInternalFailureException(v **types.InternalFailureException, 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.InternalFailureException
if *v == nil {
sv = &types.InternalFailureException{}
} 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
}
func awsRestjson1_deserializeDocumentInvalidRequestException(v **types.InvalidRequestException, 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.InvalidRequestException
if *v == nil {
sv = &types.InvalidRequestException{}
} 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
}
func awsRestjson1_deserializeDocumentIotEventsAction(v **types.IotEventsAction, 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.IotEventsAction
if *v == nil {
sv = &types.IotEventsAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "inputName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected InputName to be of type string, got %T instead", value)
}
sv.InputName = ptr.String(jtv)
}
case "payload":
if err := awsRestjson1_deserializeDocumentPayload(&sv.Payload, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentIotSiteWiseAction(v **types.IotSiteWiseAction, 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.IotSiteWiseAction
if *v == nil {
sv = &types.IotSiteWiseAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "assetId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AssetId to be of type string, got %T instead", value)
}
sv.AssetId = ptr.String(jtv)
}
case "entryId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AssetPropertyEntryId to be of type string, got %T instead", value)
}
sv.EntryId = ptr.String(jtv)
}
case "propertyAlias":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AssetPropertyAlias to be of type string, got %T instead", value)
}
sv.PropertyAlias = ptr.String(jtv)
}
case "propertyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AssetPropertyId to be of type string, got %T instead", value)
}
sv.PropertyId = ptr.String(jtv)
}
case "propertyValue":
if err := awsRestjson1_deserializeDocumentAssetPropertyValue(&sv.PropertyValue, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentIotTopicPublishAction(v **types.IotTopicPublishAction, 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.IotTopicPublishAction
if *v == nil {
sv = &types.IotTopicPublishAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "mqttTopic":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MQTTTopic to be of type string, got %T instead", value)
}
sv.MqttTopic = ptr.String(jtv)
}
case "payload":
if err := awsRestjson1_deserializeDocumentPayload(&sv.Payload, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentLambdaAction(v **types.LambdaAction, 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.LambdaAction
if *v == nil {
sv = &types.LambdaAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "functionArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value)
}
sv.FunctionArn = ptr.String(jtv)
}
case "payload":
if err := awsRestjson1_deserializeDocumentPayload(&sv.Payload, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentLimitExceededException(v **types.LimitExceededException, 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.LimitExceededException
if *v == nil {
sv = &types.LimitExceededException{}
} 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
}
func awsRestjson1_deserializeDocumentLoggingOptions(v **types.LoggingOptions, 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.LoggingOptions
if *v == nil {
sv = &types.LoggingOptions{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "detectorDebugOptions":
if err := awsRestjson1_deserializeDocumentDetectorDebugOptions(&sv.DetectorDebugOptions, value); err != nil {
return err
}
case "enabled":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected LoggingEnabled to be of type *bool, got %T instead", value)
}
sv.Enabled = jtv
}
case "level":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LoggingLevel to be of type string, got %T instead", value)
}
sv.Level = types.LoggingLevel(jtv)
}
case "roleArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value)
}
sv.RoleArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentNotificationAction(v **types.NotificationAction, 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.NotificationAction
if *v == nil {
sv = &types.NotificationAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "action":
if err := awsRestjson1_deserializeDocumentNotificationTargetActions(&sv.Action, value); err != nil {
return err
}
case "emailConfigurations":
if err := awsRestjson1_deserializeDocumentEmailConfigurations(&sv.EmailConfigurations, value); err != nil {
return err
}
case "smsConfigurations":
if err := awsRestjson1_deserializeDocumentSMSConfigurations(&sv.SmsConfigurations, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentNotificationActions(v *[]types.NotificationAction, 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.NotificationAction
if *v == nil {
cv = []types.NotificationAction{}
} else {
cv = *v
}
for _, value := range shape {
var col types.NotificationAction
destAddr := &col
if err := awsRestjson1_deserializeDocumentNotificationAction(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentNotificationTargetActions(v **types.NotificationTargetActions, 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.NotificationTargetActions
if *v == nil {
sv = &types.NotificationTargetActions{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "lambdaAction":
if err := awsRestjson1_deserializeDocumentLambdaAction(&sv.LambdaAction, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentOnEnterLifecycle(v **types.OnEnterLifecycle, 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.OnEnterLifecycle
if *v == nil {
sv = &types.OnEnterLifecycle{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "events":
if err := awsRestjson1_deserializeDocumentEvents(&sv.Events, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentOnExitLifecycle(v **types.OnExitLifecycle, 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.OnExitLifecycle
if *v == nil {
sv = &types.OnExitLifecycle{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "events":
if err := awsRestjson1_deserializeDocumentEvents(&sv.Events, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentOnInputLifecycle(v **types.OnInputLifecycle, 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.OnInputLifecycle
if *v == nil {
sv = &types.OnInputLifecycle{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "events":
if err := awsRestjson1_deserializeDocumentEvents(&sv.Events, value); err != nil {
return err
}
case "transitionEvents":
if err := awsRestjson1_deserializeDocumentTransitionEvents(&sv.TransitionEvents, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPayload(v **types.Payload, 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.Payload
if *v == nil {
sv = &types.Payload{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "contentExpression":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ContentExpression to be of type string, got %T instead", value)
}
sv.ContentExpression = ptr.String(jtv)
}
case "type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PayloadType to be of type string, got %T instead", value)
}
sv.Type = types.PayloadType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentRecipientDetail(v **types.RecipientDetail, 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.RecipientDetail
if *v == nil {
sv = &types.RecipientDetail{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ssoIdentity":
if err := awsRestjson1_deserializeDocumentSSOIdentity(&sv.SsoIdentity, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentRecipientDetails(v *[]types.RecipientDetail, 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.RecipientDetail
if *v == nil {
cv = []types.RecipientDetail{}
} else {
cv = *v
}
for _, value := range shape {
var col types.RecipientDetail
destAddr := &col
if err := awsRestjson1_deserializeDocumentRecipientDetail(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentResetTimerAction(v **types.ResetTimerAction, 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.ResetTimerAction
if *v == nil {
sv = &types.ResetTimerAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "timerName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TimerName to be of type string, got %T instead", value)
}
sv.TimerName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResourceAlreadyExistsException(v **types.ResourceAlreadyExistsException, 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.ResourceAlreadyExistsException
if *v == nil {
sv = &types.ResourceAlreadyExistsException{}
} 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)
}
case "resourceArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected resourceArn to be of type string, got %T instead", value)
}
sv.ResourceArn = ptr.String(jtv)
}
case "resourceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected resourceId to be of type string, got %T instead", value)
}
sv.ResourceId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResourceInUseException(v **types.ResourceInUseException, 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.ResourceInUseException
if *v == nil {
sv = &types.ResourceInUseException{}
} 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
}
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 errorMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentRoutedResource(v **types.RoutedResource, 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.RoutedResource
if *v == nil {
sv = &types.RoutedResource{}
} 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 AmazonResourceName to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentRoutedResources(v *[]types.RoutedResource, 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.RoutedResource
if *v == nil {
cv = []types.RoutedResource{}
} else {
cv = *v
}
for _, value := range shape {
var col types.RoutedResource
destAddr := &col
if err := awsRestjson1_deserializeDocumentRoutedResource(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentServiceUnavailableException(v **types.ServiceUnavailableException, 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.ServiceUnavailableException
if *v == nil {
sv = &types.ServiceUnavailableException{}
} 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
}
func awsRestjson1_deserializeDocumentSetTimerAction(v **types.SetTimerAction, 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.SetTimerAction
if *v == nil {
sv = &types.SetTimerAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "durationExpression":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VariableValue to be of type string, got %T instead", value)
}
sv.DurationExpression = ptr.String(jtv)
}
case "seconds":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Seconds to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Seconds = ptr.Int32(int32(i64))
}
case "timerName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TimerName to be of type string, got %T instead", value)
}
sv.TimerName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSetVariableAction(v **types.SetVariableAction, 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.SetVariableAction
if *v == nil {
sv = &types.SetVariableAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "value":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VariableValue to be of type string, got %T instead", value)
}
sv.Value = ptr.String(jtv)
}
case "variableName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VariableName to be of type string, got %T instead", value)
}
sv.VariableName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSimpleRule(v **types.SimpleRule, 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.SimpleRule
if *v == nil {
sv = &types.SimpleRule{}
} 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 "inputProperty":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected InputProperty to be of type string, got %T instead", value)
}
sv.InputProperty = ptr.String(jtv)
}
case "threshold":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Threshold to be of type string, got %T instead", value)
}
sv.Threshold = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSMSConfiguration(v **types.SMSConfiguration, 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.SMSConfiguration
if *v == nil {
sv = &types.SMSConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "additionalMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NotificationAdditionalMessage to be of type string, got %T instead", value)
}
sv.AdditionalMessage = ptr.String(jtv)
}
case "recipients":
if err := awsRestjson1_deserializeDocumentRecipientDetails(&sv.Recipients, value); err != nil {
return err
}
case "senderId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SMSSenderId to be of type string, got %T instead", value)
}
sv.SenderId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSMSConfigurations(v *[]types.SMSConfiguration, 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.SMSConfiguration
if *v == nil {
cv = []types.SMSConfiguration{}
} else {
cv = *v
}
for _, value := range shape {
var col types.SMSConfiguration
destAddr := &col
if err := awsRestjson1_deserializeDocumentSMSConfiguration(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentSNSTopicPublishAction(v **types.SNSTopicPublishAction, 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.SNSTopicPublishAction
if *v == nil {
sv = &types.SNSTopicPublishAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "payload":
if err := awsRestjson1_deserializeDocumentPayload(&sv.Payload, value); err != nil {
return err
}
case "targetArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value)
}
sv.TargetArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSqsAction(v **types.SqsAction, 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.SqsAction
if *v == nil {
sv = &types.SqsAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "payload":
if err := awsRestjson1_deserializeDocumentPayload(&sv.Payload, value); err != nil {
return err
}
case "queueUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected QueueUrl to be of type string, got %T instead", value)
}
sv.QueueUrl = ptr.String(jtv)
}
case "useBase64":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected UseBase64 to be of type *bool, got %T instead", value)
}
sv.UseBase64 = ptr.Bool(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSSOIdentity(v **types.SSOIdentity, 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.SSOIdentity
if *v == nil {
sv = &types.SSOIdentity{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "identityStoreId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected IdentityStoreId to be of type string, got %T instead", value)
}
sv.IdentityStoreId = ptr.String(jtv)
}
case "userId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SSOReferenceId to be of type string, got %T instead", value)
}
sv.UserId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentState(v **types.State, 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.State
if *v == nil {
sv = &types.State{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "onEnter":
if err := awsRestjson1_deserializeDocumentOnEnterLifecycle(&sv.OnEnter, value); err != nil {
return err
}
case "onExit":
if err := awsRestjson1_deserializeDocumentOnExitLifecycle(&sv.OnExit, value); err != nil {
return err
}
case "onInput":
if err := awsRestjson1_deserializeDocumentOnInputLifecycle(&sv.OnInput, value); err != nil {
return err
}
case "stateName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected StateName to be of type string, got %T instead", value)
}
sv.StateName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentStates(v *[]types.State, 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.State
if *v == nil {
cv = []types.State{}
} else {
cv = *v
}
for _, value := range shape {
var col types.State
destAddr := &col
if err := awsRestjson1_deserializeDocumentState(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentTag(v **types.Tag, 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.Tag
if *v == nil {
sv = &types.Tag{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "key":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TagKey to be of type string, got %T instead", value)
}
sv.Key = ptr.String(jtv)
}
case "value":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TagValue to be of type string, got %T instead", value)
}
sv.Value = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTags(v *[]types.Tag, 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.Tag
if *v == nil {
cv = []types.Tag{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Tag
destAddr := &col
if err := awsRestjson1_deserializeDocumentTag(&destAddr, value); err != nil {
return err
}
col = *destAddr
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 errorMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTransitionEvent(v **types.TransitionEvent, 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.TransitionEvent
if *v == nil {
sv = &types.TransitionEvent{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "actions":
if err := awsRestjson1_deserializeDocumentActions(&sv.Actions, value); err != nil {
return err
}
case "condition":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Condition to be of type string, got %T instead", value)
}
sv.Condition = ptr.String(jtv)
}
case "eventName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EventName to be of type string, got %T instead", value)
}
sv.EventName = ptr.String(jtv)
}
case "nextState":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected StateName to be of type string, got %T instead", value)
}
sv.NextState = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTransitionEvents(v *[]types.TransitionEvent, 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.TransitionEvent
if *v == nil {
cv = []types.TransitionEvent{}
} else {
cv = *v
}
for _, value := range shape {
var col types.TransitionEvent
destAddr := &col
if err := awsRestjson1_deserializeDocumentTransitionEvent(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentUnsupportedOperationException(v **types.UnsupportedOperationException, 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.UnsupportedOperationException
if *v == nil {
sv = &types.UnsupportedOperationException{}
} 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
}
| 8,742 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package iotevents provides the API client, operations, and parameter types for
// AWS IoT Events.
//
// AWS IoT Events monitors your equipment or device fleets for failures or changes
// in operation, and triggers actions when such events occur. You can use AWS IoT
// Events API operations to create, read, update, and delete inputs and detector
// models, and to list their versions.
package iotevents
| 11 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
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/iotevents/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 = "iotevents"
}
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 iotevents
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.15.12"
| 7 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
import (
"bytes"
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/iotevents/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_serializeOpCreateAlarmModel struct {
}
func (*awsRestjson1_serializeOpCreateAlarmModel) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateAlarmModel) 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.(*CreateAlarmModelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/alarm-models")
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_serializeOpDocumentCreateAlarmModelInput(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_serializeOpHttpBindingsCreateAlarmModelInput(v *CreateAlarmModelInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateAlarmModelInput(v *CreateAlarmModelInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AlarmCapabilities != nil {
ok := object.Key("alarmCapabilities")
if err := awsRestjson1_serializeDocumentAlarmCapabilities(v.AlarmCapabilities, ok); err != nil {
return err
}
}
if v.AlarmEventActions != nil {
ok := object.Key("alarmEventActions")
if err := awsRestjson1_serializeDocumentAlarmEventActions(v.AlarmEventActions, ok); err != nil {
return err
}
}
if v.AlarmModelDescription != nil {
ok := object.Key("alarmModelDescription")
ok.String(*v.AlarmModelDescription)
}
if v.AlarmModelName != nil {
ok := object.Key("alarmModelName")
ok.String(*v.AlarmModelName)
}
if v.AlarmNotification != nil {
ok := object.Key("alarmNotification")
if err := awsRestjson1_serializeDocumentAlarmNotification(v.AlarmNotification, ok); err != nil {
return err
}
}
if v.AlarmRule != nil {
ok := object.Key("alarmRule")
if err := awsRestjson1_serializeDocumentAlarmRule(v.AlarmRule, ok); err != nil {
return err
}
}
if v.Key != nil {
ok := object.Key("key")
ok.String(*v.Key)
}
if v.RoleArn != nil {
ok := object.Key("roleArn")
ok.String(*v.RoleArn)
}
if v.Severity != nil {
ok := object.Key("severity")
ok.Integer(*v.Severity)
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateDetectorModel struct {
}
func (*awsRestjson1_serializeOpCreateDetectorModel) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateDetectorModel) 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.(*CreateDetectorModelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/detector-models")
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_serializeOpDocumentCreateDetectorModelInput(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_serializeOpHttpBindingsCreateDetectorModelInput(v *CreateDetectorModelInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateDetectorModelInput(v *CreateDetectorModelInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DetectorModelDefinition != nil {
ok := object.Key("detectorModelDefinition")
if err := awsRestjson1_serializeDocumentDetectorModelDefinition(v.DetectorModelDefinition, ok); err != nil {
return err
}
}
if v.DetectorModelDescription != nil {
ok := object.Key("detectorModelDescription")
ok.String(*v.DetectorModelDescription)
}
if v.DetectorModelName != nil {
ok := object.Key("detectorModelName")
ok.String(*v.DetectorModelName)
}
if len(v.EvaluationMethod) > 0 {
ok := object.Key("evaluationMethod")
ok.String(string(v.EvaluationMethod))
}
if v.Key != nil {
ok := object.Key("key")
ok.String(*v.Key)
}
if v.RoleArn != nil {
ok := object.Key("roleArn")
ok.String(*v.RoleArn)
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateInput struct {
}
func (*awsRestjson1_serializeOpCreateInput) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateInput) 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.(*CreateInputInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/inputs")
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_serializeOpDocumentCreateInputInput(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_serializeOpHttpBindingsCreateInputInput(v *CreateInputInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateInputInput(v *CreateInputInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.InputDefinition != nil {
ok := object.Key("inputDefinition")
if err := awsRestjson1_serializeDocumentInputDefinition(v.InputDefinition, ok); err != nil {
return err
}
}
if v.InputDescription != nil {
ok := object.Key("inputDescription")
ok.String(*v.InputDescription)
}
if v.InputName != nil {
ok := object.Key("inputName")
ok.String(*v.InputName)
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocumentTags(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteAlarmModel struct {
}
func (*awsRestjson1_serializeOpDeleteAlarmModel) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteAlarmModel) 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.(*DeleteAlarmModelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/alarm-models/{alarmModelName}")
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_serializeOpHttpBindingsDeleteAlarmModelInput(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_serializeOpHttpBindingsDeleteAlarmModelInput(v *DeleteAlarmModelInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.AlarmModelName == nil || len(*v.AlarmModelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member alarmModelName must not be empty")}
}
if v.AlarmModelName != nil {
if err := encoder.SetURI("alarmModelName").String(*v.AlarmModelName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteDetectorModel struct {
}
func (*awsRestjson1_serializeOpDeleteDetectorModel) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteDetectorModel) 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.(*DeleteDetectorModelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/detector-models/{detectorModelName}")
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_serializeOpHttpBindingsDeleteDetectorModelInput(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_serializeOpHttpBindingsDeleteDetectorModelInput(v *DeleteDetectorModelInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.DetectorModelName == nil || len(*v.DetectorModelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member detectorModelName must not be empty")}
}
if v.DetectorModelName != nil {
if err := encoder.SetURI("detectorModelName").String(*v.DetectorModelName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteInput struct {
}
func (*awsRestjson1_serializeOpDeleteInput) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteInput) 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.(*DeleteInputInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/inputs/{inputName}")
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_serializeOpHttpBindingsDeleteInputInput(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_serializeOpHttpBindingsDeleteInputInput(v *DeleteInputInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.InputName == nil || len(*v.InputName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member inputName must not be empty")}
}
if v.InputName != nil {
if err := encoder.SetURI("inputName").String(*v.InputName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDescribeAlarmModel struct {
}
func (*awsRestjson1_serializeOpDescribeAlarmModel) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDescribeAlarmModel) 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.(*DescribeAlarmModelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/alarm-models/{alarmModelName}")
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_serializeOpHttpBindingsDescribeAlarmModelInput(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_serializeOpHttpBindingsDescribeAlarmModelInput(v *DescribeAlarmModelInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.AlarmModelName == nil || len(*v.AlarmModelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member alarmModelName must not be empty")}
}
if v.AlarmModelName != nil {
if err := encoder.SetURI("alarmModelName").String(*v.AlarmModelName); err != nil {
return err
}
}
if v.AlarmModelVersion != nil {
encoder.SetQuery("version").String(*v.AlarmModelVersion)
}
return nil
}
type awsRestjson1_serializeOpDescribeDetectorModel struct {
}
func (*awsRestjson1_serializeOpDescribeDetectorModel) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDescribeDetectorModel) 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.(*DescribeDetectorModelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/detector-models/{detectorModelName}")
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_serializeOpHttpBindingsDescribeDetectorModelInput(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_serializeOpHttpBindingsDescribeDetectorModelInput(v *DescribeDetectorModelInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.DetectorModelName == nil || len(*v.DetectorModelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member detectorModelName must not be empty")}
}
if v.DetectorModelName != nil {
if err := encoder.SetURI("detectorModelName").String(*v.DetectorModelName); err != nil {
return err
}
}
if v.DetectorModelVersion != nil {
encoder.SetQuery("version").String(*v.DetectorModelVersion)
}
return nil
}
type awsRestjson1_serializeOpDescribeDetectorModelAnalysis struct {
}
func (*awsRestjson1_serializeOpDescribeDetectorModelAnalysis) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDescribeDetectorModelAnalysis) 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.(*DescribeDetectorModelAnalysisInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/analysis/detector-models/{analysisId}")
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_serializeOpHttpBindingsDescribeDetectorModelAnalysisInput(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_serializeOpHttpBindingsDescribeDetectorModelAnalysisInput(v *DescribeDetectorModelAnalysisInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.AnalysisId == nil || len(*v.AnalysisId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member analysisId must not be empty")}
}
if v.AnalysisId != nil {
if err := encoder.SetURI("analysisId").String(*v.AnalysisId); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDescribeInput struct {
}
func (*awsRestjson1_serializeOpDescribeInput) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDescribeInput) 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.(*DescribeInputInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/inputs/{inputName}")
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_serializeOpHttpBindingsDescribeInputInput(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_serializeOpHttpBindingsDescribeInputInput(v *DescribeInputInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.InputName == nil || len(*v.InputName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member inputName must not be empty")}
}
if v.InputName != nil {
if err := encoder.SetURI("inputName").String(*v.InputName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDescribeLoggingOptions struct {
}
func (*awsRestjson1_serializeOpDescribeLoggingOptions) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDescribeLoggingOptions) 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.(*DescribeLoggingOptionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/logging")
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 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_serializeOpHttpBindingsDescribeLoggingOptionsInput(v *DescribeLoggingOptionsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
type awsRestjson1_serializeOpGetDetectorModelAnalysisResults struct {
}
func (*awsRestjson1_serializeOpGetDetectorModelAnalysisResults) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetDetectorModelAnalysisResults) 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.(*GetDetectorModelAnalysisResultsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/analysis/detector-models/{analysisId}/results")
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_serializeOpHttpBindingsGetDetectorModelAnalysisResultsInput(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_serializeOpHttpBindingsGetDetectorModelAnalysisResultsInput(v *GetDetectorModelAnalysisResultsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.AnalysisId == nil || len(*v.AnalysisId) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member analysisId must not be empty")}
}
if v.AnalysisId != nil {
if err := encoder.SetURI("analysisId").String(*v.AnalysisId); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListAlarmModels struct {
}
func (*awsRestjson1_serializeOpListAlarmModels) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListAlarmModels) 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.(*ListAlarmModelsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/alarm-models")
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_serializeOpHttpBindingsListAlarmModelsInput(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_serializeOpHttpBindingsListAlarmModelsInput(v *ListAlarmModelsInput, 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_serializeOpListAlarmModelVersions struct {
}
func (*awsRestjson1_serializeOpListAlarmModelVersions) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListAlarmModelVersions) 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.(*ListAlarmModelVersionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/alarm-models/{alarmModelName}/versions")
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_serializeOpHttpBindingsListAlarmModelVersionsInput(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_serializeOpHttpBindingsListAlarmModelVersionsInput(v *ListAlarmModelVersionsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.AlarmModelName == nil || len(*v.AlarmModelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member alarmModelName must not be empty")}
}
if v.AlarmModelName != nil {
if err := encoder.SetURI("alarmModelName").String(*v.AlarmModelName); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListDetectorModels struct {
}
func (*awsRestjson1_serializeOpListDetectorModels) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListDetectorModels) 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.(*ListDetectorModelsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/detector-models")
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_serializeOpHttpBindingsListDetectorModelsInput(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_serializeOpHttpBindingsListDetectorModelsInput(v *ListDetectorModelsInput, 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_serializeOpListDetectorModelVersions struct {
}
func (*awsRestjson1_serializeOpListDetectorModelVersions) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListDetectorModelVersions) 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.(*ListDetectorModelVersionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/detector-models/{detectorModelName}/versions")
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_serializeOpHttpBindingsListDetectorModelVersionsInput(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_serializeOpHttpBindingsListDetectorModelVersionsInput(v *ListDetectorModelVersionsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.DetectorModelName == nil || len(*v.DetectorModelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member detectorModelName must not be empty")}
}
if v.DetectorModelName != nil {
if err := encoder.SetURI("detectorModelName").String(*v.DetectorModelName); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListInputRoutings struct {
}
func (*awsRestjson1_serializeOpListInputRoutings) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListInputRoutings) 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.(*ListInputRoutingsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/input-routings")
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_serializeOpDocumentListInputRoutingsInput(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_serializeOpHttpBindingsListInputRoutingsInput(v *ListInputRoutingsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentListInputRoutingsInput(v *ListInputRoutingsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.InputIdentifier != nil {
ok := object.Key("inputIdentifier")
if err := awsRestjson1_serializeDocumentInputIdentifier(v.InputIdentifier, ok); err != nil {
return err
}
}
if v.MaxResults != nil {
ok := object.Key("maxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("nextToken")
ok.String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListInputs struct {
}
func (*awsRestjson1_serializeOpListInputs) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListInputs) 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.(*ListInputsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/inputs")
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_serializeOpHttpBindingsListInputsInput(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_serializeOpHttpBindingsListInputsInput(v *ListInputsInput, 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")
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 {
encoder.SetQuery("resourceArn").String(*v.ResourceArn)
}
return nil
}
type awsRestjson1_serializeOpPutLoggingOptions struct {
}
func (*awsRestjson1_serializeOpPutLoggingOptions) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpPutLoggingOptions) 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.(*PutLoggingOptionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/logging")
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_serializeOpDocumentPutLoggingOptionsInput(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_serializeOpHttpBindingsPutLoggingOptionsInput(v *PutLoggingOptionsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentPutLoggingOptionsInput(v *PutLoggingOptionsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LoggingOptions != nil {
ok := object.Key("loggingOptions")
if err := awsRestjson1_serializeDocumentLoggingOptions(v.LoggingOptions, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpStartDetectorModelAnalysis struct {
}
func (*awsRestjson1_serializeOpStartDetectorModelAnalysis) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartDetectorModelAnalysis) 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.(*StartDetectorModelAnalysisInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/analysis/detector-models")
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_serializeOpDocumentStartDetectorModelAnalysisInput(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_serializeOpHttpBindingsStartDetectorModelAnalysisInput(v *StartDetectorModelAnalysisInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentStartDetectorModelAnalysisInput(v *StartDetectorModelAnalysisInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DetectorModelDefinition != nil {
ok := object.Key("detectorModelDefinition")
if err := awsRestjson1_serializeDocumentDetectorModelDefinition(v.DetectorModelDefinition, ok); err != nil {
return err
}
}
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")
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_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 {
encoder.SetQuery("resourceArn").String(*v.ResourceArn)
}
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")
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 {
encoder.SetQuery("resourceArn").String(*v.ResourceArn)
}
if v.TagKeys != nil {
for i := range v.TagKeys {
encoder.AddQuery("tagKeys").String(v.TagKeys[i])
}
}
return nil
}
type awsRestjson1_serializeOpUpdateAlarmModel struct {
}
func (*awsRestjson1_serializeOpUpdateAlarmModel) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateAlarmModel) 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.(*UpdateAlarmModelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/alarm-models/{alarmModelName}")
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_serializeOpHttpBindingsUpdateAlarmModelInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateAlarmModelInput(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_serializeOpHttpBindingsUpdateAlarmModelInput(v *UpdateAlarmModelInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.AlarmModelName == nil || len(*v.AlarmModelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member alarmModelName must not be empty")}
}
if v.AlarmModelName != nil {
if err := encoder.SetURI("alarmModelName").String(*v.AlarmModelName); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateAlarmModelInput(v *UpdateAlarmModelInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AlarmCapabilities != nil {
ok := object.Key("alarmCapabilities")
if err := awsRestjson1_serializeDocumentAlarmCapabilities(v.AlarmCapabilities, ok); err != nil {
return err
}
}
if v.AlarmEventActions != nil {
ok := object.Key("alarmEventActions")
if err := awsRestjson1_serializeDocumentAlarmEventActions(v.AlarmEventActions, ok); err != nil {
return err
}
}
if v.AlarmModelDescription != nil {
ok := object.Key("alarmModelDescription")
ok.String(*v.AlarmModelDescription)
}
if v.AlarmNotification != nil {
ok := object.Key("alarmNotification")
if err := awsRestjson1_serializeDocumentAlarmNotification(v.AlarmNotification, ok); err != nil {
return err
}
}
if v.AlarmRule != nil {
ok := object.Key("alarmRule")
if err := awsRestjson1_serializeDocumentAlarmRule(v.AlarmRule, ok); err != nil {
return err
}
}
if v.RoleArn != nil {
ok := object.Key("roleArn")
ok.String(*v.RoleArn)
}
if v.Severity != nil {
ok := object.Key("severity")
ok.Integer(*v.Severity)
}
return nil
}
type awsRestjson1_serializeOpUpdateDetectorModel struct {
}
func (*awsRestjson1_serializeOpUpdateDetectorModel) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateDetectorModel) 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.(*UpdateDetectorModelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/detector-models/{detectorModelName}")
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_serializeOpHttpBindingsUpdateDetectorModelInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateDetectorModelInput(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_serializeOpHttpBindingsUpdateDetectorModelInput(v *UpdateDetectorModelInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.DetectorModelName == nil || len(*v.DetectorModelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member detectorModelName must not be empty")}
}
if v.DetectorModelName != nil {
if err := encoder.SetURI("detectorModelName").String(*v.DetectorModelName); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateDetectorModelInput(v *UpdateDetectorModelInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DetectorModelDefinition != nil {
ok := object.Key("detectorModelDefinition")
if err := awsRestjson1_serializeDocumentDetectorModelDefinition(v.DetectorModelDefinition, ok); err != nil {
return err
}
}
if v.DetectorModelDescription != nil {
ok := object.Key("detectorModelDescription")
ok.String(*v.DetectorModelDescription)
}
if len(v.EvaluationMethod) > 0 {
ok := object.Key("evaluationMethod")
ok.String(string(v.EvaluationMethod))
}
if v.RoleArn != nil {
ok := object.Key("roleArn")
ok.String(*v.RoleArn)
}
return nil
}
type awsRestjson1_serializeOpUpdateInput struct {
}
func (*awsRestjson1_serializeOpUpdateInput) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateInput) 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.(*UpdateInputInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/inputs/{inputName}")
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_serializeOpHttpBindingsUpdateInputInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateInputInput(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_serializeOpHttpBindingsUpdateInputInput(v *UpdateInputInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.InputName == nil || len(*v.InputName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member inputName must not be empty")}
}
if v.InputName != nil {
if err := encoder.SetURI("inputName").String(*v.InputName); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateInputInput(v *UpdateInputInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.InputDefinition != nil {
ok := object.Key("inputDefinition")
if err := awsRestjson1_serializeDocumentInputDefinition(v.InputDefinition, ok); err != nil {
return err
}
}
if v.InputDescription != nil {
ok := object.Key("inputDescription")
ok.String(*v.InputDescription)
}
return nil
}
func awsRestjson1_serializeDocumentAcknowledgeFlow(v *types.AcknowledgeFlow, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Enabled != nil {
ok := object.Key("enabled")
ok.Boolean(*v.Enabled)
}
return nil
}
func awsRestjson1_serializeDocumentAction(v *types.Action, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClearTimer != nil {
ok := object.Key("clearTimer")
if err := awsRestjson1_serializeDocumentClearTimerAction(v.ClearTimer, ok); err != nil {
return err
}
}
if v.DynamoDB != nil {
ok := object.Key("dynamoDB")
if err := awsRestjson1_serializeDocumentDynamoDBAction(v.DynamoDB, ok); err != nil {
return err
}
}
if v.DynamoDBv2 != nil {
ok := object.Key("dynamoDBv2")
if err := awsRestjson1_serializeDocumentDynamoDBv2Action(v.DynamoDBv2, ok); err != nil {
return err
}
}
if v.Firehose != nil {
ok := object.Key("firehose")
if err := awsRestjson1_serializeDocumentFirehoseAction(v.Firehose, ok); err != nil {
return err
}
}
if v.IotEvents != nil {
ok := object.Key("iotEvents")
if err := awsRestjson1_serializeDocumentIotEventsAction(v.IotEvents, ok); err != nil {
return err
}
}
if v.IotSiteWise != nil {
ok := object.Key("iotSiteWise")
if err := awsRestjson1_serializeDocumentIotSiteWiseAction(v.IotSiteWise, ok); err != nil {
return err
}
}
if v.IotTopicPublish != nil {
ok := object.Key("iotTopicPublish")
if err := awsRestjson1_serializeDocumentIotTopicPublishAction(v.IotTopicPublish, ok); err != nil {
return err
}
}
if v.Lambda != nil {
ok := object.Key("lambda")
if err := awsRestjson1_serializeDocumentLambdaAction(v.Lambda, ok); err != nil {
return err
}
}
if v.ResetTimer != nil {
ok := object.Key("resetTimer")
if err := awsRestjson1_serializeDocumentResetTimerAction(v.ResetTimer, ok); err != nil {
return err
}
}
if v.SetTimer != nil {
ok := object.Key("setTimer")
if err := awsRestjson1_serializeDocumentSetTimerAction(v.SetTimer, ok); err != nil {
return err
}
}
if v.SetVariable != nil {
ok := object.Key("setVariable")
if err := awsRestjson1_serializeDocumentSetVariableAction(v.SetVariable, ok); err != nil {
return err
}
}
if v.Sns != nil {
ok := object.Key("sns")
if err := awsRestjson1_serializeDocumentSNSTopicPublishAction(v.Sns, ok); err != nil {
return err
}
}
if v.Sqs != nil {
ok := object.Key("sqs")
if err := awsRestjson1_serializeDocumentSqsAction(v.Sqs, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentActions(v []types.Action, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentAction(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentAlarmAction(v *types.AlarmAction, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DynamoDB != nil {
ok := object.Key("dynamoDB")
if err := awsRestjson1_serializeDocumentDynamoDBAction(v.DynamoDB, ok); err != nil {
return err
}
}
if v.DynamoDBv2 != nil {
ok := object.Key("dynamoDBv2")
if err := awsRestjson1_serializeDocumentDynamoDBv2Action(v.DynamoDBv2, ok); err != nil {
return err
}
}
if v.Firehose != nil {
ok := object.Key("firehose")
if err := awsRestjson1_serializeDocumentFirehoseAction(v.Firehose, ok); err != nil {
return err
}
}
if v.IotEvents != nil {
ok := object.Key("iotEvents")
if err := awsRestjson1_serializeDocumentIotEventsAction(v.IotEvents, ok); err != nil {
return err
}
}
if v.IotSiteWise != nil {
ok := object.Key("iotSiteWise")
if err := awsRestjson1_serializeDocumentIotSiteWiseAction(v.IotSiteWise, ok); err != nil {
return err
}
}
if v.IotTopicPublish != nil {
ok := object.Key("iotTopicPublish")
if err := awsRestjson1_serializeDocumentIotTopicPublishAction(v.IotTopicPublish, ok); err != nil {
return err
}
}
if v.Lambda != nil {
ok := object.Key("lambda")
if err := awsRestjson1_serializeDocumentLambdaAction(v.Lambda, ok); err != nil {
return err
}
}
if v.Sns != nil {
ok := object.Key("sns")
if err := awsRestjson1_serializeDocumentSNSTopicPublishAction(v.Sns, ok); err != nil {
return err
}
}
if v.Sqs != nil {
ok := object.Key("sqs")
if err := awsRestjson1_serializeDocumentSqsAction(v.Sqs, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentAlarmActions(v []types.AlarmAction, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentAlarmAction(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentAlarmCapabilities(v *types.AlarmCapabilities, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AcknowledgeFlow != nil {
ok := object.Key("acknowledgeFlow")
if err := awsRestjson1_serializeDocumentAcknowledgeFlow(v.AcknowledgeFlow, ok); err != nil {
return err
}
}
if v.InitializationConfiguration != nil {
ok := object.Key("initializationConfiguration")
if err := awsRestjson1_serializeDocumentInitializationConfiguration(v.InitializationConfiguration, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentAlarmEventActions(v *types.AlarmEventActions, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AlarmActions != nil {
ok := object.Key("alarmActions")
if err := awsRestjson1_serializeDocumentAlarmActions(v.AlarmActions, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentAlarmNotification(v *types.AlarmNotification, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.NotificationActions != nil {
ok := object.Key("notificationActions")
if err := awsRestjson1_serializeDocumentNotificationActions(v.NotificationActions, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentAlarmRule(v *types.AlarmRule, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.SimpleRule != nil {
ok := object.Key("simpleRule")
if err := awsRestjson1_serializeDocumentSimpleRule(v.SimpleRule, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentAssetPropertyTimestamp(v *types.AssetPropertyTimestamp, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.OffsetInNanos != nil {
ok := object.Key("offsetInNanos")
ok.String(*v.OffsetInNanos)
}
if v.TimeInSeconds != nil {
ok := object.Key("timeInSeconds")
ok.String(*v.TimeInSeconds)
}
return nil
}
func awsRestjson1_serializeDocumentAssetPropertyValue(v *types.AssetPropertyValue, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Quality != nil {
ok := object.Key("quality")
ok.String(*v.Quality)
}
if v.Timestamp != nil {
ok := object.Key("timestamp")
if err := awsRestjson1_serializeDocumentAssetPropertyTimestamp(v.Timestamp, ok); err != nil {
return err
}
}
if v.Value != nil {
ok := object.Key("value")
if err := awsRestjson1_serializeDocumentAssetPropertyVariant(v.Value, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentAssetPropertyVariant(v *types.AssetPropertyVariant, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.BooleanValue != nil {
ok := object.Key("booleanValue")
ok.String(*v.BooleanValue)
}
if v.DoubleValue != nil {
ok := object.Key("doubleValue")
ok.String(*v.DoubleValue)
}
if v.IntegerValue != nil {
ok := object.Key("integerValue")
ok.String(*v.IntegerValue)
}
if v.StringValue != nil {
ok := object.Key("stringValue")
ok.String(*v.StringValue)
}
return nil
}
func awsRestjson1_serializeDocumentAttribute(v *types.Attribute, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.JsonPath != nil {
ok := object.Key("jsonPath")
ok.String(*v.JsonPath)
}
return nil
}
func awsRestjson1_serializeDocumentAttributes(v []types.Attribute, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentAttribute(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentClearTimerAction(v *types.ClearTimerAction, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.TimerName != nil {
ok := object.Key("timerName")
ok.String(*v.TimerName)
}
return nil
}
func awsRestjson1_serializeDocumentDetectorDebugOption(v *types.DetectorDebugOption, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DetectorModelName != nil {
ok := object.Key("detectorModelName")
ok.String(*v.DetectorModelName)
}
if v.KeyValue != nil {
ok := object.Key("keyValue")
ok.String(*v.KeyValue)
}
return nil
}
func awsRestjson1_serializeDocumentDetectorDebugOptions(v []types.DetectorDebugOption, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentDetectorDebugOption(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentDetectorModelDefinition(v *types.DetectorModelDefinition, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.InitialStateName != nil {
ok := object.Key("initialStateName")
ok.String(*v.InitialStateName)
}
if v.States != nil {
ok := object.Key("states")
if err := awsRestjson1_serializeDocumentStates(v.States, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentDynamoDBAction(v *types.DynamoDBAction, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.HashKeyField != nil {
ok := object.Key("hashKeyField")
ok.String(*v.HashKeyField)
}
if v.HashKeyType != nil {
ok := object.Key("hashKeyType")
ok.String(*v.HashKeyType)
}
if v.HashKeyValue != nil {
ok := object.Key("hashKeyValue")
ok.String(*v.HashKeyValue)
}
if v.Operation != nil {
ok := object.Key("operation")
ok.String(*v.Operation)
}
if v.Payload != nil {
ok := object.Key("payload")
if err := awsRestjson1_serializeDocumentPayload(v.Payload, ok); err != nil {
return err
}
}
if v.PayloadField != nil {
ok := object.Key("payloadField")
ok.String(*v.PayloadField)
}
if v.RangeKeyField != nil {
ok := object.Key("rangeKeyField")
ok.String(*v.RangeKeyField)
}
if v.RangeKeyType != nil {
ok := object.Key("rangeKeyType")
ok.String(*v.RangeKeyType)
}
if v.RangeKeyValue != nil {
ok := object.Key("rangeKeyValue")
ok.String(*v.RangeKeyValue)
}
if v.TableName != nil {
ok := object.Key("tableName")
ok.String(*v.TableName)
}
return nil
}
func awsRestjson1_serializeDocumentDynamoDBv2Action(v *types.DynamoDBv2Action, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Payload != nil {
ok := object.Key("payload")
if err := awsRestjson1_serializeDocumentPayload(v.Payload, ok); err != nil {
return err
}
}
if v.TableName != nil {
ok := object.Key("tableName")
ok.String(*v.TableName)
}
return nil
}
func awsRestjson1_serializeDocumentEmailConfiguration(v *types.EmailConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Content != nil {
ok := object.Key("content")
if err := awsRestjson1_serializeDocumentEmailContent(v.Content, ok); err != nil {
return err
}
}
if v.From != nil {
ok := object.Key("from")
ok.String(*v.From)
}
if v.Recipients != nil {
ok := object.Key("recipients")
if err := awsRestjson1_serializeDocumentEmailRecipients(v.Recipients, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentEmailConfigurations(v []types.EmailConfiguration, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentEmailConfiguration(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentEmailContent(v *types.EmailContent, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AdditionalMessage != nil {
ok := object.Key("additionalMessage")
ok.String(*v.AdditionalMessage)
}
if v.Subject != nil {
ok := object.Key("subject")
ok.String(*v.Subject)
}
return nil
}
func awsRestjson1_serializeDocumentEmailRecipients(v *types.EmailRecipients, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.To != nil {
ok := object.Key("to")
if err := awsRestjson1_serializeDocumentRecipientDetails(v.To, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentEvent(v *types.Event, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Actions != nil {
ok := object.Key("actions")
if err := awsRestjson1_serializeDocumentActions(v.Actions, ok); err != nil {
return err
}
}
if v.Condition != nil {
ok := object.Key("condition")
ok.String(*v.Condition)
}
if v.EventName != nil {
ok := object.Key("eventName")
ok.String(*v.EventName)
}
return nil
}
func awsRestjson1_serializeDocumentEvents(v []types.Event, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentEvent(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentFirehoseAction(v *types.FirehoseAction, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DeliveryStreamName != nil {
ok := object.Key("deliveryStreamName")
ok.String(*v.DeliveryStreamName)
}
if v.Payload != nil {
ok := object.Key("payload")
if err := awsRestjson1_serializeDocumentPayload(v.Payload, ok); err != nil {
return err
}
}
if v.Separator != nil {
ok := object.Key("separator")
ok.String(*v.Separator)
}
return nil
}
func awsRestjson1_serializeDocumentInitializationConfiguration(v *types.InitializationConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DisabledOnInitialization != nil {
ok := object.Key("disabledOnInitialization")
ok.Boolean(*v.DisabledOnInitialization)
}
return nil
}
func awsRestjson1_serializeDocumentInputDefinition(v *types.InputDefinition, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Attributes != nil {
ok := object.Key("attributes")
if err := awsRestjson1_serializeDocumentAttributes(v.Attributes, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentInputIdentifier(v *types.InputIdentifier, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.IotEventsInputIdentifier != nil {
ok := object.Key("iotEventsInputIdentifier")
if err := awsRestjson1_serializeDocumentIotEventsInputIdentifier(v.IotEventsInputIdentifier, ok); err != nil {
return err
}
}
if v.IotSiteWiseInputIdentifier != nil {
ok := object.Key("iotSiteWiseInputIdentifier")
if err := awsRestjson1_serializeDocumentIotSiteWiseInputIdentifier(v.IotSiteWiseInputIdentifier, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentIotEventsAction(v *types.IotEventsAction, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.InputName != nil {
ok := object.Key("inputName")
ok.String(*v.InputName)
}
if v.Payload != nil {
ok := object.Key("payload")
if err := awsRestjson1_serializeDocumentPayload(v.Payload, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentIotEventsInputIdentifier(v *types.IotEventsInputIdentifier, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.InputName != nil {
ok := object.Key("inputName")
ok.String(*v.InputName)
}
return nil
}
func awsRestjson1_serializeDocumentIotSiteWiseAction(v *types.IotSiteWiseAction, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AssetId != nil {
ok := object.Key("assetId")
ok.String(*v.AssetId)
}
if v.EntryId != nil {
ok := object.Key("entryId")
ok.String(*v.EntryId)
}
if v.PropertyAlias != nil {
ok := object.Key("propertyAlias")
ok.String(*v.PropertyAlias)
}
if v.PropertyId != nil {
ok := object.Key("propertyId")
ok.String(*v.PropertyId)
}
if v.PropertyValue != nil {
ok := object.Key("propertyValue")
if err := awsRestjson1_serializeDocumentAssetPropertyValue(v.PropertyValue, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentIotSiteWiseAssetModelPropertyIdentifier(v *types.IotSiteWiseAssetModelPropertyIdentifier, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AssetModelId != nil {
ok := object.Key("assetModelId")
ok.String(*v.AssetModelId)
}
if v.PropertyId != nil {
ok := object.Key("propertyId")
ok.String(*v.PropertyId)
}
return nil
}
func awsRestjson1_serializeDocumentIotSiteWiseInputIdentifier(v *types.IotSiteWiseInputIdentifier, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.IotSiteWiseAssetModelPropertyIdentifier != nil {
ok := object.Key("iotSiteWiseAssetModelPropertyIdentifier")
if err := awsRestjson1_serializeDocumentIotSiteWiseAssetModelPropertyIdentifier(v.IotSiteWiseAssetModelPropertyIdentifier, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentIotTopicPublishAction(v *types.IotTopicPublishAction, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MqttTopic != nil {
ok := object.Key("mqttTopic")
ok.String(*v.MqttTopic)
}
if v.Payload != nil {
ok := object.Key("payload")
if err := awsRestjson1_serializeDocumentPayload(v.Payload, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentLambdaAction(v *types.LambdaAction, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FunctionArn != nil {
ok := object.Key("functionArn")
ok.String(*v.FunctionArn)
}
if v.Payload != nil {
ok := object.Key("payload")
if err := awsRestjson1_serializeDocumentPayload(v.Payload, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentLoggingOptions(v *types.LoggingOptions, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DetectorDebugOptions != nil {
ok := object.Key("detectorDebugOptions")
if err := awsRestjson1_serializeDocumentDetectorDebugOptions(v.DetectorDebugOptions, ok); err != nil {
return err
}
}
{
ok := object.Key("enabled")
ok.Boolean(v.Enabled)
}
if len(v.Level) > 0 {
ok := object.Key("level")
ok.String(string(v.Level))
}
if v.RoleArn != nil {
ok := object.Key("roleArn")
ok.String(*v.RoleArn)
}
return nil
}
func awsRestjson1_serializeDocumentNotificationAction(v *types.NotificationAction, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Action != nil {
ok := object.Key("action")
if err := awsRestjson1_serializeDocumentNotificationTargetActions(v.Action, ok); err != nil {
return err
}
}
if v.EmailConfigurations != nil {
ok := object.Key("emailConfigurations")
if err := awsRestjson1_serializeDocumentEmailConfigurations(v.EmailConfigurations, ok); err != nil {
return err
}
}
if v.SmsConfigurations != nil {
ok := object.Key("smsConfigurations")
if err := awsRestjson1_serializeDocumentSMSConfigurations(v.SmsConfigurations, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentNotificationActions(v []types.NotificationAction, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentNotificationAction(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentNotificationTargetActions(v *types.NotificationTargetActions, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LambdaAction != nil {
ok := object.Key("lambdaAction")
if err := awsRestjson1_serializeDocumentLambdaAction(v.LambdaAction, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentOnEnterLifecycle(v *types.OnEnterLifecycle, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Events != nil {
ok := object.Key("events")
if err := awsRestjson1_serializeDocumentEvents(v.Events, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentOnExitLifecycle(v *types.OnExitLifecycle, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Events != nil {
ok := object.Key("events")
if err := awsRestjson1_serializeDocumentEvents(v.Events, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentOnInputLifecycle(v *types.OnInputLifecycle, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Events != nil {
ok := object.Key("events")
if err := awsRestjson1_serializeDocumentEvents(v.Events, ok); err != nil {
return err
}
}
if v.TransitionEvents != nil {
ok := object.Key("transitionEvents")
if err := awsRestjson1_serializeDocumentTransitionEvents(v.TransitionEvents, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentPayload(v *types.Payload, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ContentExpression != nil {
ok := object.Key("contentExpression")
ok.String(*v.ContentExpression)
}
if len(v.Type) > 0 {
ok := object.Key("type")
ok.String(string(v.Type))
}
return nil
}
func awsRestjson1_serializeDocumentRecipientDetail(v *types.RecipientDetail, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.SsoIdentity != nil {
ok := object.Key("ssoIdentity")
if err := awsRestjson1_serializeDocumentSSOIdentity(v.SsoIdentity, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentRecipientDetails(v []types.RecipientDetail, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentRecipientDetail(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentResetTimerAction(v *types.ResetTimerAction, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.TimerName != nil {
ok := object.Key("timerName")
ok.String(*v.TimerName)
}
return nil
}
func awsRestjson1_serializeDocumentSetTimerAction(v *types.SetTimerAction, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DurationExpression != nil {
ok := object.Key("durationExpression")
ok.String(*v.DurationExpression)
}
if v.Seconds != nil {
ok := object.Key("seconds")
ok.Integer(*v.Seconds)
}
if v.TimerName != nil {
ok := object.Key("timerName")
ok.String(*v.TimerName)
}
return nil
}
func awsRestjson1_serializeDocumentSetVariableAction(v *types.SetVariableAction, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Value != nil {
ok := object.Key("value")
ok.String(*v.Value)
}
if v.VariableName != nil {
ok := object.Key("variableName")
ok.String(*v.VariableName)
}
return nil
}
func awsRestjson1_serializeDocumentSimpleRule(v *types.SimpleRule, 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.InputProperty != nil {
ok := object.Key("inputProperty")
ok.String(*v.InputProperty)
}
if v.Threshold != nil {
ok := object.Key("threshold")
ok.String(*v.Threshold)
}
return nil
}
func awsRestjson1_serializeDocumentSMSConfiguration(v *types.SMSConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AdditionalMessage != nil {
ok := object.Key("additionalMessage")
ok.String(*v.AdditionalMessage)
}
if v.Recipients != nil {
ok := object.Key("recipients")
if err := awsRestjson1_serializeDocumentRecipientDetails(v.Recipients, ok); err != nil {
return err
}
}
if v.SenderId != nil {
ok := object.Key("senderId")
ok.String(*v.SenderId)
}
return nil
}
func awsRestjson1_serializeDocumentSMSConfigurations(v []types.SMSConfiguration, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentSMSConfiguration(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentSNSTopicPublishAction(v *types.SNSTopicPublishAction, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Payload != nil {
ok := object.Key("payload")
if err := awsRestjson1_serializeDocumentPayload(v.Payload, ok); err != nil {
return err
}
}
if v.TargetArn != nil {
ok := object.Key("targetArn")
ok.String(*v.TargetArn)
}
return nil
}
func awsRestjson1_serializeDocumentSqsAction(v *types.SqsAction, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Payload != nil {
ok := object.Key("payload")
if err := awsRestjson1_serializeDocumentPayload(v.Payload, ok); err != nil {
return err
}
}
if v.QueueUrl != nil {
ok := object.Key("queueUrl")
ok.String(*v.QueueUrl)
}
if v.UseBase64 != nil {
ok := object.Key("useBase64")
ok.Boolean(*v.UseBase64)
}
return nil
}
func awsRestjson1_serializeDocumentSSOIdentity(v *types.SSOIdentity, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.IdentityStoreId != nil {
ok := object.Key("identityStoreId")
ok.String(*v.IdentityStoreId)
}
if v.UserId != nil {
ok := object.Key("userId")
ok.String(*v.UserId)
}
return nil
}
func awsRestjson1_serializeDocumentState(v *types.State, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.OnEnter != nil {
ok := object.Key("onEnter")
if err := awsRestjson1_serializeDocumentOnEnterLifecycle(v.OnEnter, ok); err != nil {
return err
}
}
if v.OnExit != nil {
ok := object.Key("onExit")
if err := awsRestjson1_serializeDocumentOnExitLifecycle(v.OnExit, ok); err != nil {
return err
}
}
if v.OnInput != nil {
ok := object.Key("onInput")
if err := awsRestjson1_serializeDocumentOnInputLifecycle(v.OnInput, ok); err != nil {
return err
}
}
if v.StateName != nil {
ok := object.Key("stateName")
ok.String(*v.StateName)
}
return nil
}
func awsRestjson1_serializeDocumentStates(v []types.State, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentState(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Key != nil {
ok := object.Key("key")
ok.String(*v.Key)
}
if v.Value != nil {
ok := object.Key("value")
ok.String(*v.Value)
}
return nil
}
func awsRestjson1_serializeDocumentTags(v []types.Tag, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentTag(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentTransitionEvent(v *types.TransitionEvent, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Actions != nil {
ok := object.Key("actions")
if err := awsRestjson1_serializeDocumentActions(v.Actions, ok); err != nil {
return err
}
}
if v.Condition != nil {
ok := object.Key("condition")
ok.String(*v.Condition)
}
if v.EventName != nil {
ok := object.Key("eventName")
ok.String(*v.EventName)
}
if v.NextState != nil {
ok := object.Key("nextState")
ok.String(*v.NextState)
}
return nil
}
func awsRestjson1_serializeDocumentTransitionEvents(v []types.TransitionEvent, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentTransitionEvent(&v[i], av); err != nil {
return err
}
}
return nil
}
| 3,151 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package iotevents
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/iotevents/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpCreateAlarmModel struct {
}
func (*validateOpCreateAlarmModel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateAlarmModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateAlarmModelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateAlarmModelInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateDetectorModel struct {
}
func (*validateOpCreateDetectorModel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateDetectorModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateDetectorModelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateDetectorModelInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateInput struct {
}
func (*validateOpCreateInput) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateInput) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateInputInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateInputInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteAlarmModel struct {
}
func (*validateOpDeleteAlarmModel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteAlarmModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteAlarmModelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteAlarmModelInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteDetectorModel struct {
}
func (*validateOpDeleteDetectorModel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteDetectorModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteDetectorModelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteDetectorModelInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteInput struct {
}
func (*validateOpDeleteInput) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteInput) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteInputInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteInputInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeAlarmModel struct {
}
func (*validateOpDescribeAlarmModel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeAlarmModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeAlarmModelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeAlarmModelInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeDetectorModelAnalysis struct {
}
func (*validateOpDescribeDetectorModelAnalysis) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeDetectorModelAnalysis) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeDetectorModelAnalysisInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeDetectorModelAnalysisInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeDetectorModel struct {
}
func (*validateOpDescribeDetectorModel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeDetectorModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeDetectorModelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeDetectorModelInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeInput struct {
}
func (*validateOpDescribeInput) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeInput) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeInputInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeInputInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetDetectorModelAnalysisResults struct {
}
func (*validateOpGetDetectorModelAnalysisResults) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetDetectorModelAnalysisResults) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetDetectorModelAnalysisResultsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetDetectorModelAnalysisResultsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListAlarmModelVersions struct {
}
func (*validateOpListAlarmModelVersions) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListAlarmModelVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListAlarmModelVersionsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListAlarmModelVersionsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListDetectorModelVersions struct {
}
func (*validateOpListDetectorModelVersions) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListDetectorModelVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListDetectorModelVersionsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListDetectorModelVersionsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListInputRoutings struct {
}
func (*validateOpListInputRoutings) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListInputRoutings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListInputRoutingsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListInputRoutingsInput(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 validateOpPutLoggingOptions struct {
}
func (*validateOpPutLoggingOptions) ID() string {
return "OperationInputValidation"
}
func (m *validateOpPutLoggingOptions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*PutLoggingOptionsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpPutLoggingOptionsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartDetectorModelAnalysis struct {
}
func (*validateOpStartDetectorModelAnalysis) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartDetectorModelAnalysis) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartDetectorModelAnalysisInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartDetectorModelAnalysisInput(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)
}
type validateOpUpdateAlarmModel struct {
}
func (*validateOpUpdateAlarmModel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateAlarmModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateAlarmModelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateAlarmModelInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateDetectorModel struct {
}
func (*validateOpUpdateDetectorModel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateDetectorModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateDetectorModelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateDetectorModelInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateInput struct {
}
func (*validateOpUpdateInput) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateInput) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateInputInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateInputInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpCreateAlarmModelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateAlarmModel{}, middleware.After)
}
func addOpCreateDetectorModelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateDetectorModel{}, middleware.After)
}
func addOpCreateInputValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateInput{}, middleware.After)
}
func addOpDeleteAlarmModelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteAlarmModel{}, middleware.After)
}
func addOpDeleteDetectorModelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteDetectorModel{}, middleware.After)
}
func addOpDeleteInputValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteInput{}, middleware.After)
}
func addOpDescribeAlarmModelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeAlarmModel{}, middleware.After)
}
func addOpDescribeDetectorModelAnalysisValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeDetectorModelAnalysis{}, middleware.After)
}
func addOpDescribeDetectorModelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeDetectorModel{}, middleware.After)
}
func addOpDescribeInputValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeInput{}, middleware.After)
}
func addOpGetDetectorModelAnalysisResultsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetDetectorModelAnalysisResults{}, middleware.After)
}
func addOpListAlarmModelVersionsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListAlarmModelVersions{}, middleware.After)
}
func addOpListDetectorModelVersionsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListDetectorModelVersions{}, middleware.After)
}
func addOpListInputRoutingsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListInputRoutings{}, middleware.After)
}
func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
}
func addOpPutLoggingOptionsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpPutLoggingOptions{}, middleware.After)
}
func addOpStartDetectorModelAnalysisValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartDetectorModelAnalysis{}, 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 addOpUpdateAlarmModelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateAlarmModel{}, middleware.After)
}
func addOpUpdateDetectorModelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateDetectorModel{}, middleware.After)
}
func addOpUpdateInputValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateInput{}, middleware.After)
}
func validateAcknowledgeFlow(v *types.AcknowledgeFlow) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AcknowledgeFlow"}
if v.Enabled == nil {
invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAction(v *types.Action) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Action"}
if v.SetVariable != nil {
if err := validateSetVariableAction(v.SetVariable); err != nil {
invalidParams.AddNested("SetVariable", err.(smithy.InvalidParamsError))
}
}
if v.Sns != nil {
if err := validateSNSTopicPublishAction(v.Sns); err != nil {
invalidParams.AddNested("Sns", err.(smithy.InvalidParamsError))
}
}
if v.IotTopicPublish != nil {
if err := validateIotTopicPublishAction(v.IotTopicPublish); err != nil {
invalidParams.AddNested("IotTopicPublish", err.(smithy.InvalidParamsError))
}
}
if v.SetTimer != nil {
if err := validateSetTimerAction(v.SetTimer); err != nil {
invalidParams.AddNested("SetTimer", err.(smithy.InvalidParamsError))
}
}
if v.ClearTimer != nil {
if err := validateClearTimerAction(v.ClearTimer); err != nil {
invalidParams.AddNested("ClearTimer", err.(smithy.InvalidParamsError))
}
}
if v.ResetTimer != nil {
if err := validateResetTimerAction(v.ResetTimer); err != nil {
invalidParams.AddNested("ResetTimer", err.(smithy.InvalidParamsError))
}
}
if v.Lambda != nil {
if err := validateLambdaAction(v.Lambda); err != nil {
invalidParams.AddNested("Lambda", err.(smithy.InvalidParamsError))
}
}
if v.IotEvents != nil {
if err := validateIotEventsAction(v.IotEvents); err != nil {
invalidParams.AddNested("IotEvents", err.(smithy.InvalidParamsError))
}
}
if v.Sqs != nil {
if err := validateSqsAction(v.Sqs); err != nil {
invalidParams.AddNested("Sqs", err.(smithy.InvalidParamsError))
}
}
if v.Firehose != nil {
if err := validateFirehoseAction(v.Firehose); err != nil {
invalidParams.AddNested("Firehose", err.(smithy.InvalidParamsError))
}
}
if v.DynamoDB != nil {
if err := validateDynamoDBAction(v.DynamoDB); err != nil {
invalidParams.AddNested("DynamoDB", err.(smithy.InvalidParamsError))
}
}
if v.DynamoDBv2 != nil {
if err := validateDynamoDBv2Action(v.DynamoDBv2); err != nil {
invalidParams.AddNested("DynamoDBv2", err.(smithy.InvalidParamsError))
}
}
if v.IotSiteWise != nil {
if err := validateIotSiteWiseAction(v.IotSiteWise); err != nil {
invalidParams.AddNested("IotSiteWise", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateActions(v []types.Action) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Actions"}
for i := range v {
if err := validateAction(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAlarmAction(v *types.AlarmAction) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AlarmAction"}
if v.Sns != nil {
if err := validateSNSTopicPublishAction(v.Sns); err != nil {
invalidParams.AddNested("Sns", err.(smithy.InvalidParamsError))
}
}
if v.IotTopicPublish != nil {
if err := validateIotTopicPublishAction(v.IotTopicPublish); err != nil {
invalidParams.AddNested("IotTopicPublish", err.(smithy.InvalidParamsError))
}
}
if v.Lambda != nil {
if err := validateLambdaAction(v.Lambda); err != nil {
invalidParams.AddNested("Lambda", err.(smithy.InvalidParamsError))
}
}
if v.IotEvents != nil {
if err := validateIotEventsAction(v.IotEvents); err != nil {
invalidParams.AddNested("IotEvents", err.(smithy.InvalidParamsError))
}
}
if v.Sqs != nil {
if err := validateSqsAction(v.Sqs); err != nil {
invalidParams.AddNested("Sqs", err.(smithy.InvalidParamsError))
}
}
if v.Firehose != nil {
if err := validateFirehoseAction(v.Firehose); err != nil {
invalidParams.AddNested("Firehose", err.(smithy.InvalidParamsError))
}
}
if v.DynamoDB != nil {
if err := validateDynamoDBAction(v.DynamoDB); err != nil {
invalidParams.AddNested("DynamoDB", err.(smithy.InvalidParamsError))
}
}
if v.DynamoDBv2 != nil {
if err := validateDynamoDBv2Action(v.DynamoDBv2); err != nil {
invalidParams.AddNested("DynamoDBv2", err.(smithy.InvalidParamsError))
}
}
if v.IotSiteWise != nil {
if err := validateIotSiteWiseAction(v.IotSiteWise); err != nil {
invalidParams.AddNested("IotSiteWise", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAlarmActions(v []types.AlarmAction) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AlarmActions"}
for i := range v {
if err := validateAlarmAction(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAlarmCapabilities(v *types.AlarmCapabilities) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AlarmCapabilities"}
if v.InitializationConfiguration != nil {
if err := validateInitializationConfiguration(v.InitializationConfiguration); err != nil {
invalidParams.AddNested("InitializationConfiguration", err.(smithy.InvalidParamsError))
}
}
if v.AcknowledgeFlow != nil {
if err := validateAcknowledgeFlow(v.AcknowledgeFlow); err != nil {
invalidParams.AddNested("AcknowledgeFlow", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAlarmEventActions(v *types.AlarmEventActions) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AlarmEventActions"}
if v.AlarmActions != nil {
if err := validateAlarmActions(v.AlarmActions); err != nil {
invalidParams.AddNested("AlarmActions", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAlarmNotification(v *types.AlarmNotification) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AlarmNotification"}
if v.NotificationActions != nil {
if err := validateNotificationActions(v.NotificationActions); err != nil {
invalidParams.AddNested("NotificationActions", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAlarmRule(v *types.AlarmRule) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AlarmRule"}
if v.SimpleRule != nil {
if err := validateSimpleRule(v.SimpleRule); err != nil {
invalidParams.AddNested("SimpleRule", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAssetPropertyTimestamp(v *types.AssetPropertyTimestamp) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AssetPropertyTimestamp"}
if v.TimeInSeconds == nil {
invalidParams.Add(smithy.NewErrParamRequired("TimeInSeconds"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAssetPropertyValue(v *types.AssetPropertyValue) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AssetPropertyValue"}
if v.Timestamp != nil {
if err := validateAssetPropertyTimestamp(v.Timestamp); err != nil {
invalidParams.AddNested("Timestamp", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAttribute(v *types.Attribute) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Attribute"}
if v.JsonPath == nil {
invalidParams.Add(smithy.NewErrParamRequired("JsonPath"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAttributes(v []types.Attribute) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Attributes"}
for i := range v {
if err := validateAttribute(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateClearTimerAction(v *types.ClearTimerAction) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ClearTimerAction"}
if v.TimerName == nil {
invalidParams.Add(smithy.NewErrParamRequired("TimerName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDetectorDebugOption(v *types.DetectorDebugOption) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DetectorDebugOption"}
if v.DetectorModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DetectorModelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDetectorDebugOptions(v []types.DetectorDebugOption) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DetectorDebugOptions"}
for i := range v {
if err := validateDetectorDebugOption(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDetectorModelDefinition(v *types.DetectorModelDefinition) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DetectorModelDefinition"}
if v.States == nil {
invalidParams.Add(smithy.NewErrParamRequired("States"))
} else if v.States != nil {
if err := validateStates(v.States); err != nil {
invalidParams.AddNested("States", err.(smithy.InvalidParamsError))
}
}
if v.InitialStateName == nil {
invalidParams.Add(smithy.NewErrParamRequired("InitialStateName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDynamoDBAction(v *types.DynamoDBAction) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DynamoDBAction"}
if v.HashKeyField == nil {
invalidParams.Add(smithy.NewErrParamRequired("HashKeyField"))
}
if v.HashKeyValue == nil {
invalidParams.Add(smithy.NewErrParamRequired("HashKeyValue"))
}
if v.TableName == nil {
invalidParams.Add(smithy.NewErrParamRequired("TableName"))
}
if v.Payload != nil {
if err := validatePayload(v.Payload); err != nil {
invalidParams.AddNested("Payload", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDynamoDBv2Action(v *types.DynamoDBv2Action) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DynamoDBv2Action"}
if v.TableName == nil {
invalidParams.Add(smithy.NewErrParamRequired("TableName"))
}
if v.Payload != nil {
if err := validatePayload(v.Payload); err != nil {
invalidParams.AddNested("Payload", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateEmailConfiguration(v *types.EmailConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "EmailConfiguration"}
if v.From == nil {
invalidParams.Add(smithy.NewErrParamRequired("From"))
}
if v.Recipients == nil {
invalidParams.Add(smithy.NewErrParamRequired("Recipients"))
} else if v.Recipients != nil {
if err := validateEmailRecipients(v.Recipients); err != nil {
invalidParams.AddNested("Recipients", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateEmailConfigurations(v []types.EmailConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "EmailConfigurations"}
for i := range v {
if err := validateEmailConfiguration(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateEmailRecipients(v *types.EmailRecipients) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "EmailRecipients"}
if v.To != nil {
if err := validateRecipientDetails(v.To); err != nil {
invalidParams.AddNested("To", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateEvent(v *types.Event) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Event"}
if v.EventName == nil {
invalidParams.Add(smithy.NewErrParamRequired("EventName"))
}
if v.Actions != nil {
if err := validateActions(v.Actions); err != nil {
invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateEvents(v []types.Event) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Events"}
for i := range v {
if err := validateEvent(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateFirehoseAction(v *types.FirehoseAction) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "FirehoseAction"}
if v.DeliveryStreamName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DeliveryStreamName"))
}
if v.Payload != nil {
if err := validatePayload(v.Payload); err != nil {
invalidParams.AddNested("Payload", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateInitializationConfiguration(v *types.InitializationConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "InitializationConfiguration"}
if v.DisabledOnInitialization == nil {
invalidParams.Add(smithy.NewErrParamRequired("DisabledOnInitialization"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateInputDefinition(v *types.InputDefinition) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "InputDefinition"}
if v.Attributes == nil {
invalidParams.Add(smithy.NewErrParamRequired("Attributes"))
} else if v.Attributes != nil {
if err := validateAttributes(v.Attributes); err != nil {
invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateInputIdentifier(v *types.InputIdentifier) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "InputIdentifier"}
if v.IotEventsInputIdentifier != nil {
if err := validateIotEventsInputIdentifier(v.IotEventsInputIdentifier); err != nil {
invalidParams.AddNested("IotEventsInputIdentifier", err.(smithy.InvalidParamsError))
}
}
if v.IotSiteWiseInputIdentifier != nil {
if err := validateIotSiteWiseInputIdentifier(v.IotSiteWiseInputIdentifier); err != nil {
invalidParams.AddNested("IotSiteWiseInputIdentifier", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateIotEventsAction(v *types.IotEventsAction) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "IotEventsAction"}
if v.InputName == nil {
invalidParams.Add(smithy.NewErrParamRequired("InputName"))
}
if v.Payload != nil {
if err := validatePayload(v.Payload); err != nil {
invalidParams.AddNested("Payload", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateIotEventsInputIdentifier(v *types.IotEventsInputIdentifier) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "IotEventsInputIdentifier"}
if v.InputName == nil {
invalidParams.Add(smithy.NewErrParamRequired("InputName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateIotSiteWiseAction(v *types.IotSiteWiseAction) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "IotSiteWiseAction"}
if v.PropertyValue != nil {
if err := validateAssetPropertyValue(v.PropertyValue); err != nil {
invalidParams.AddNested("PropertyValue", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateIotSiteWiseAssetModelPropertyIdentifier(v *types.IotSiteWiseAssetModelPropertyIdentifier) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "IotSiteWiseAssetModelPropertyIdentifier"}
if v.AssetModelId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AssetModelId"))
}
if v.PropertyId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PropertyId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateIotSiteWiseInputIdentifier(v *types.IotSiteWiseInputIdentifier) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "IotSiteWiseInputIdentifier"}
if v.IotSiteWiseAssetModelPropertyIdentifier != nil {
if err := validateIotSiteWiseAssetModelPropertyIdentifier(v.IotSiteWiseAssetModelPropertyIdentifier); err != nil {
invalidParams.AddNested("IotSiteWiseAssetModelPropertyIdentifier", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateIotTopicPublishAction(v *types.IotTopicPublishAction) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "IotTopicPublishAction"}
if v.MqttTopic == nil {
invalidParams.Add(smithy.NewErrParamRequired("MqttTopic"))
}
if v.Payload != nil {
if err := validatePayload(v.Payload); err != nil {
invalidParams.AddNested("Payload", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateLambdaAction(v *types.LambdaAction) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "LambdaAction"}
if v.FunctionArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("FunctionArn"))
}
if v.Payload != nil {
if err := validatePayload(v.Payload); err != nil {
invalidParams.AddNested("Payload", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateLoggingOptions(v *types.LoggingOptions) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "LoggingOptions"}
if v.RoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
}
if len(v.Level) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Level"))
}
if v.DetectorDebugOptions != nil {
if err := validateDetectorDebugOptions(v.DetectorDebugOptions); err != nil {
invalidParams.AddNested("DetectorDebugOptions", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateNotificationAction(v *types.NotificationAction) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "NotificationAction"}
if v.Action == nil {
invalidParams.Add(smithy.NewErrParamRequired("Action"))
} else if v.Action != nil {
if err := validateNotificationTargetActions(v.Action); err != nil {
invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
}
}
if v.SmsConfigurations != nil {
if err := validateSMSConfigurations(v.SmsConfigurations); err != nil {
invalidParams.AddNested("SmsConfigurations", err.(smithy.InvalidParamsError))
}
}
if v.EmailConfigurations != nil {
if err := validateEmailConfigurations(v.EmailConfigurations); err != nil {
invalidParams.AddNested("EmailConfigurations", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateNotificationActions(v []types.NotificationAction) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "NotificationActions"}
for i := range v {
if err := validateNotificationAction(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateNotificationTargetActions(v *types.NotificationTargetActions) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "NotificationTargetActions"}
if v.LambdaAction != nil {
if err := validateLambdaAction(v.LambdaAction); err != nil {
invalidParams.AddNested("LambdaAction", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOnEnterLifecycle(v *types.OnEnterLifecycle) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "OnEnterLifecycle"}
if v.Events != nil {
if err := validateEvents(v.Events); err != nil {
invalidParams.AddNested("Events", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOnExitLifecycle(v *types.OnExitLifecycle) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "OnExitLifecycle"}
if v.Events != nil {
if err := validateEvents(v.Events); err != nil {
invalidParams.AddNested("Events", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOnInputLifecycle(v *types.OnInputLifecycle) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "OnInputLifecycle"}
if v.Events != nil {
if err := validateEvents(v.Events); err != nil {
invalidParams.AddNested("Events", err.(smithy.InvalidParamsError))
}
}
if v.TransitionEvents != nil {
if err := validateTransitionEvents(v.TransitionEvents); err != nil {
invalidParams.AddNested("TransitionEvents", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validatePayload(v *types.Payload) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Payload"}
if v.ContentExpression == nil {
invalidParams.Add(smithy.NewErrParamRequired("ContentExpression"))
}
if len(v.Type) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Type"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateRecipientDetail(v *types.RecipientDetail) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RecipientDetail"}
if v.SsoIdentity != nil {
if err := validateSSOIdentity(v.SsoIdentity); err != nil {
invalidParams.AddNested("SsoIdentity", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateRecipientDetails(v []types.RecipientDetail) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RecipientDetails"}
for i := range v {
if err := validateRecipientDetail(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateResetTimerAction(v *types.ResetTimerAction) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ResetTimerAction"}
if v.TimerName == nil {
invalidParams.Add(smithy.NewErrParamRequired("TimerName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSetTimerAction(v *types.SetTimerAction) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SetTimerAction"}
if v.TimerName == nil {
invalidParams.Add(smithy.NewErrParamRequired("TimerName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSetVariableAction(v *types.SetVariableAction) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SetVariableAction"}
if v.VariableName == nil {
invalidParams.Add(smithy.NewErrParamRequired("VariableName"))
}
if v.Value == nil {
invalidParams.Add(smithy.NewErrParamRequired("Value"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSimpleRule(v *types.SimpleRule) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SimpleRule"}
if v.InputProperty == nil {
invalidParams.Add(smithy.NewErrParamRequired("InputProperty"))
}
if len(v.ComparisonOperator) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ComparisonOperator"))
}
if v.Threshold == nil {
invalidParams.Add(smithy.NewErrParamRequired("Threshold"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSMSConfiguration(v *types.SMSConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SMSConfiguration"}
if v.Recipients == nil {
invalidParams.Add(smithy.NewErrParamRequired("Recipients"))
} else if v.Recipients != nil {
if err := validateRecipientDetails(v.Recipients); err != nil {
invalidParams.AddNested("Recipients", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSMSConfigurations(v []types.SMSConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SMSConfigurations"}
for i := range v {
if err := validateSMSConfiguration(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSNSTopicPublishAction(v *types.SNSTopicPublishAction) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SNSTopicPublishAction"}
if v.TargetArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("TargetArn"))
}
if v.Payload != nil {
if err := validatePayload(v.Payload); err != nil {
invalidParams.AddNested("Payload", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSqsAction(v *types.SqsAction) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SqsAction"}
if v.QueueUrl == nil {
invalidParams.Add(smithy.NewErrParamRequired("QueueUrl"))
}
if v.Payload != nil {
if err := validatePayload(v.Payload); err != nil {
invalidParams.AddNested("Payload", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSSOIdentity(v *types.SSOIdentity) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SSOIdentity"}
if v.IdentityStoreId == nil {
invalidParams.Add(smithy.NewErrParamRequired("IdentityStoreId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateState(v *types.State) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "State"}
if v.StateName == nil {
invalidParams.Add(smithy.NewErrParamRequired("StateName"))
}
if v.OnInput != nil {
if err := validateOnInputLifecycle(v.OnInput); err != nil {
invalidParams.AddNested("OnInput", err.(smithy.InvalidParamsError))
}
}
if v.OnEnter != nil {
if err := validateOnEnterLifecycle(v.OnEnter); err != nil {
invalidParams.AddNested("OnEnter", err.(smithy.InvalidParamsError))
}
}
if v.OnExit != nil {
if err := validateOnExitLifecycle(v.OnExit); err != nil {
invalidParams.AddNested("OnExit", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateStates(v []types.State) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "States"}
for i := range v {
if err := validateState(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTag(v *types.Tag) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Tag"}
if v.Key == nil {
invalidParams.Add(smithy.NewErrParamRequired("Key"))
}
if v.Value == nil {
invalidParams.Add(smithy.NewErrParamRequired("Value"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTags(v []types.Tag) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Tags"}
for i := range v {
if err := validateTag(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTransitionEvent(v *types.TransitionEvent) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TransitionEvent"}
if v.EventName == nil {
invalidParams.Add(smithy.NewErrParamRequired("EventName"))
}
if v.Condition == nil {
invalidParams.Add(smithy.NewErrParamRequired("Condition"))
}
if v.Actions != nil {
if err := validateActions(v.Actions); err != nil {
invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
}
}
if v.NextState == nil {
invalidParams.Add(smithy.NewErrParamRequired("NextState"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTransitionEvents(v []types.TransitionEvent) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TransitionEvents"}
for i := range v {
if err := validateTransitionEvent(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateAlarmModelInput(v *CreateAlarmModelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateAlarmModelInput"}
if v.AlarmModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("AlarmModelName"))
}
if v.RoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
}
if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if v.AlarmRule == nil {
invalidParams.Add(smithy.NewErrParamRequired("AlarmRule"))
} else if v.AlarmRule != nil {
if err := validateAlarmRule(v.AlarmRule); err != nil {
invalidParams.AddNested("AlarmRule", err.(smithy.InvalidParamsError))
}
}
if v.AlarmNotification != nil {
if err := validateAlarmNotification(v.AlarmNotification); err != nil {
invalidParams.AddNested("AlarmNotification", err.(smithy.InvalidParamsError))
}
}
if v.AlarmEventActions != nil {
if err := validateAlarmEventActions(v.AlarmEventActions); err != nil {
invalidParams.AddNested("AlarmEventActions", err.(smithy.InvalidParamsError))
}
}
if v.AlarmCapabilities != nil {
if err := validateAlarmCapabilities(v.AlarmCapabilities); err != nil {
invalidParams.AddNested("AlarmCapabilities", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateDetectorModelInput(v *CreateDetectorModelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateDetectorModelInput"}
if v.DetectorModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DetectorModelName"))
}
if v.DetectorModelDefinition == nil {
invalidParams.Add(smithy.NewErrParamRequired("DetectorModelDefinition"))
} else if v.DetectorModelDefinition != nil {
if err := validateDetectorModelDefinition(v.DetectorModelDefinition); err != nil {
invalidParams.AddNested("DetectorModelDefinition", err.(smithy.InvalidParamsError))
}
}
if v.RoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
}
if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateInputInput(v *CreateInputInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateInputInput"}
if v.InputName == nil {
invalidParams.Add(smithy.NewErrParamRequired("InputName"))
}
if v.InputDefinition == nil {
invalidParams.Add(smithy.NewErrParamRequired("InputDefinition"))
} else if v.InputDefinition != nil {
if err := validateInputDefinition(v.InputDefinition); err != nil {
invalidParams.AddNested("InputDefinition", err.(smithy.InvalidParamsError))
}
}
if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteAlarmModelInput(v *DeleteAlarmModelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteAlarmModelInput"}
if v.AlarmModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("AlarmModelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteDetectorModelInput(v *DeleteDetectorModelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteDetectorModelInput"}
if v.DetectorModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DetectorModelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteInputInput(v *DeleteInputInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteInputInput"}
if v.InputName == nil {
invalidParams.Add(smithy.NewErrParamRequired("InputName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeAlarmModelInput(v *DescribeAlarmModelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeAlarmModelInput"}
if v.AlarmModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("AlarmModelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeDetectorModelAnalysisInput(v *DescribeDetectorModelAnalysisInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeDetectorModelAnalysisInput"}
if v.AnalysisId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AnalysisId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeDetectorModelInput(v *DescribeDetectorModelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeDetectorModelInput"}
if v.DetectorModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DetectorModelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeInputInput(v *DescribeInputInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeInputInput"}
if v.InputName == nil {
invalidParams.Add(smithy.NewErrParamRequired("InputName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetDetectorModelAnalysisResultsInput(v *GetDetectorModelAnalysisResultsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetDetectorModelAnalysisResultsInput"}
if v.AnalysisId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AnalysisId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListAlarmModelVersionsInput(v *ListAlarmModelVersionsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListAlarmModelVersionsInput"}
if v.AlarmModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("AlarmModelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListDetectorModelVersionsInput(v *ListDetectorModelVersionsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListDetectorModelVersionsInput"}
if v.DetectorModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DetectorModelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListInputRoutingsInput(v *ListInputRoutingsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListInputRoutingsInput"}
if v.InputIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("InputIdentifier"))
} else if v.InputIdentifier != nil {
if err := validateInputIdentifier(v.InputIdentifier); err != nil {
invalidParams.AddNested("InputIdentifier", err.(smithy.InvalidParamsError))
}
}
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 validateOpPutLoggingOptionsInput(v *PutLoggingOptionsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PutLoggingOptionsInput"}
if v.LoggingOptions == nil {
invalidParams.Add(smithy.NewErrParamRequired("LoggingOptions"))
} else if v.LoggingOptions != nil {
if err := validateLoggingOptions(v.LoggingOptions); err != nil {
invalidParams.AddNested("LoggingOptions", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartDetectorModelAnalysisInput(v *StartDetectorModelAnalysisInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartDetectorModelAnalysisInput"}
if v.DetectorModelDefinition == nil {
invalidParams.Add(smithy.NewErrParamRequired("DetectorModelDefinition"))
} else if v.DetectorModelDefinition != nil {
if err := validateDetectorModelDefinition(v.DetectorModelDefinition); err != nil {
invalidParams.AddNested("DetectorModelDefinition", err.(smithy.InvalidParamsError))
}
}
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"))
} else if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
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
}
}
func validateOpUpdateAlarmModelInput(v *UpdateAlarmModelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateAlarmModelInput"}
if v.AlarmModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("AlarmModelName"))
}
if v.RoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
}
if v.AlarmRule == nil {
invalidParams.Add(smithy.NewErrParamRequired("AlarmRule"))
} else if v.AlarmRule != nil {
if err := validateAlarmRule(v.AlarmRule); err != nil {
invalidParams.AddNested("AlarmRule", err.(smithy.InvalidParamsError))
}
}
if v.AlarmNotification != nil {
if err := validateAlarmNotification(v.AlarmNotification); err != nil {
invalidParams.AddNested("AlarmNotification", err.(smithy.InvalidParamsError))
}
}
if v.AlarmEventActions != nil {
if err := validateAlarmEventActions(v.AlarmEventActions); err != nil {
invalidParams.AddNested("AlarmEventActions", err.(smithy.InvalidParamsError))
}
}
if v.AlarmCapabilities != nil {
if err := validateAlarmCapabilities(v.AlarmCapabilities); err != nil {
invalidParams.AddNested("AlarmCapabilities", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateDetectorModelInput(v *UpdateDetectorModelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateDetectorModelInput"}
if v.DetectorModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DetectorModelName"))
}
if v.DetectorModelDefinition == nil {
invalidParams.Add(smithy.NewErrParamRequired("DetectorModelDefinition"))
} else if v.DetectorModelDefinition != nil {
if err := validateDetectorModelDefinition(v.DetectorModelDefinition); err != nil {
invalidParams.AddNested("DetectorModelDefinition", err.(smithy.InvalidParamsError))
}
}
if v.RoleArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateInputInput(v *UpdateInputInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateInputInput"}
if v.InputName == nil {
invalidParams.Add(smithy.NewErrParamRequired("InputName"))
}
if v.InputDefinition == nil {
invalidParams.Add(smithy.NewErrParamRequired("InputDefinition"))
} else if v.InputDefinition != nil {
if err := validateInputDefinition(v.InputDefinition); err != nil {
invalidParams.AddNested("InputDefinition", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 2,201 |
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 IoT Events 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: "iotevents.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "iotevents-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "iotevents-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "iotevents.{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: "ap-northeast-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ca-central-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ca-central-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "iotevents-fips.ca-central-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "eu-central-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "fips-ca-central-1",
}: endpoints.Endpoint{
Hostname: "iotevents-fips.ca-central-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "ca-central-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-us-east-1",
}: endpoints.Endpoint{
Hostname: "iotevents-fips.us-east-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-east-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-us-east-2",
}: endpoints.Endpoint{
Hostname: "iotevents-fips.us-east-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-east-2",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-us-west-2",
}: endpoints.Endpoint{
Hostname: "iotevents-fips.us-west-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-west-2",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "us-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-east-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "iotevents-fips.us-east-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-east-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-east-2",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "iotevents-fips.us-east-2.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-west-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-west-2",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "iotevents-fips.us-west-2.amazonaws.com",
},
},
},
{
ID: "aws-cn",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "iotevents.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "iotevents-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "iotevents-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "iotevents.{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{},
},
},
{
ID: "aws-iso",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "iotevents-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "iotevents.{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: "iotevents-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "iotevents.{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: "iotevents-fips.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "iotevents.{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: "iotevents-fips.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "iotevents.{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: "iotevents.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "iotevents-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "iotevents-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "iotevents.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "fips-us-gov-west-1",
}: endpoints.Endpoint{
Hostname: "iotevents-fips.us-gov-west-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-gov-west-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "us-gov-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-gov-west-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "iotevents-fips.us-gov-west-1.amazonaws.com",
},
},
},
}
| 420 |
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 AlarmModelVersionStatus string
// Enum values for AlarmModelVersionStatus
const (
AlarmModelVersionStatusActive AlarmModelVersionStatus = "ACTIVE"
AlarmModelVersionStatusActivating AlarmModelVersionStatus = "ACTIVATING"
AlarmModelVersionStatusInactive AlarmModelVersionStatus = "INACTIVE"
AlarmModelVersionStatusFailed AlarmModelVersionStatus = "FAILED"
)
// Values returns all known values for AlarmModelVersionStatus. 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 (AlarmModelVersionStatus) Values() []AlarmModelVersionStatus {
return []AlarmModelVersionStatus{
"ACTIVE",
"ACTIVATING",
"INACTIVE",
"FAILED",
}
}
type AnalysisResultLevel string
// Enum values for AnalysisResultLevel
const (
AnalysisResultLevelInfo AnalysisResultLevel = "INFO"
AnalysisResultLevelWarning AnalysisResultLevel = "WARNING"
AnalysisResultLevelError AnalysisResultLevel = "ERROR"
)
// Values returns all known values for AnalysisResultLevel. 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 (AnalysisResultLevel) Values() []AnalysisResultLevel {
return []AnalysisResultLevel{
"INFO",
"WARNING",
"ERROR",
}
}
type AnalysisStatus string
// Enum values for AnalysisStatus
const (
AnalysisStatusRunning AnalysisStatus = "RUNNING"
AnalysisStatusComplete AnalysisStatus = "COMPLETE"
AnalysisStatusFailed AnalysisStatus = "FAILED"
)
// Values returns all known values for AnalysisStatus. 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 (AnalysisStatus) Values() []AnalysisStatus {
return []AnalysisStatus{
"RUNNING",
"COMPLETE",
"FAILED",
}
}
type ComparisonOperator string
// Enum values for ComparisonOperator
const (
ComparisonOperatorGreater ComparisonOperator = "GREATER"
ComparisonOperatorGreaterOrEqual ComparisonOperator = "GREATER_OR_EQUAL"
ComparisonOperatorLess ComparisonOperator = "LESS"
ComparisonOperatorLessOrEqual ComparisonOperator = "LESS_OR_EQUAL"
ComparisonOperatorEqual ComparisonOperator = "EQUAL"
ComparisonOperatorNotEqual ComparisonOperator = "NOT_EQUAL"
)
// 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{
"GREATER",
"GREATER_OR_EQUAL",
"LESS",
"LESS_OR_EQUAL",
"EQUAL",
"NOT_EQUAL",
}
}
type DetectorModelVersionStatus string
// Enum values for DetectorModelVersionStatus
const (
DetectorModelVersionStatusActive DetectorModelVersionStatus = "ACTIVE"
DetectorModelVersionStatusActivating DetectorModelVersionStatus = "ACTIVATING"
DetectorModelVersionStatusInactive DetectorModelVersionStatus = "INACTIVE"
DetectorModelVersionStatusDeprecated DetectorModelVersionStatus = "DEPRECATED"
DetectorModelVersionStatusDraft DetectorModelVersionStatus = "DRAFT"
DetectorModelVersionStatusPaused DetectorModelVersionStatus = "PAUSED"
DetectorModelVersionStatusFailed DetectorModelVersionStatus = "FAILED"
)
// Values returns all known values for DetectorModelVersionStatus. 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 (DetectorModelVersionStatus) Values() []DetectorModelVersionStatus {
return []DetectorModelVersionStatus{
"ACTIVE",
"ACTIVATING",
"INACTIVE",
"DEPRECATED",
"DRAFT",
"PAUSED",
"FAILED",
}
}
type EvaluationMethod string
// Enum values for EvaluationMethod
const (
EvaluationMethodBatch EvaluationMethod = "BATCH"
EvaluationMethodSerial EvaluationMethod = "SERIAL"
)
// Values returns all known values for EvaluationMethod. 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 (EvaluationMethod) Values() []EvaluationMethod {
return []EvaluationMethod{
"BATCH",
"SERIAL",
}
}
type InputStatus string
// Enum values for InputStatus
const (
InputStatusCreating InputStatus = "CREATING"
InputStatusUpdating InputStatus = "UPDATING"
InputStatusActive InputStatus = "ACTIVE"
InputStatusDeleting InputStatus = "DELETING"
)
// Values returns all known values for InputStatus. 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 (InputStatus) Values() []InputStatus {
return []InputStatus{
"CREATING",
"UPDATING",
"ACTIVE",
"DELETING",
}
}
type LoggingLevel string
// Enum values for LoggingLevel
const (
LoggingLevelError LoggingLevel = "ERROR"
LoggingLevelInfo LoggingLevel = "INFO"
LoggingLevelDebug LoggingLevel = "DEBUG"
)
// Values returns all known values for LoggingLevel. 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 (LoggingLevel) Values() []LoggingLevel {
return []LoggingLevel{
"ERROR",
"INFO",
"DEBUG",
}
}
type PayloadType string
// Enum values for PayloadType
const (
PayloadTypeString PayloadType = "STRING"
PayloadTypeJson PayloadType = "JSON"
)
// Values returns all known values for PayloadType. 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 (PayloadType) Values() []PayloadType {
return []PayloadType{
"STRING",
"JSON",
}
}
| 198 |
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.
type InternalFailureException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InternalFailureException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InternalFailureException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InternalFailureException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InternalFailureException"
}
return *e.ErrorCodeOverride
}
func (e *InternalFailureException) ErrorFault() smithy.ErrorFault { return smithy.FaultServer }
// The request was invalid.
type InvalidRequestException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidRequestException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidRequestException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidRequestException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidRequestException"
}
return *e.ErrorCodeOverride
}
func (e *InvalidRequestException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// A limit was exceeded.
type LimitExceededException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *LimitExceededException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *LimitExceededException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *LimitExceededException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "LimitExceededException"
}
return *e.ErrorCodeOverride
}
func (e *LimitExceededException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The resource already exists.
type ResourceAlreadyExistsException struct {
Message *string
ErrorCodeOverride *string
ResourceId *string
ResourceArn *string
noSmithyDocumentSerde
}
func (e *ResourceAlreadyExistsException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ResourceAlreadyExistsException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ResourceAlreadyExistsException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ResourceAlreadyExistsException"
}
return *e.ErrorCodeOverride
}
func (e *ResourceAlreadyExistsException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The resource is in use.
type ResourceInUseException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ResourceInUseException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ResourceInUseException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ResourceInUseException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ResourceInUseException"
}
return *e.ErrorCodeOverride
}
func (e *ResourceInUseException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The resource was not found.
type ResourceNotFoundException struct {
Message *string
ErrorCodeOverride *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 }
// The service is currently unavailable.
type ServiceUnavailableException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ServiceUnavailableException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ServiceUnavailableException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ServiceUnavailableException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ServiceUnavailableException"
}
return *e.ErrorCodeOverride
}
func (e *ServiceUnavailableException) ErrorFault() smithy.ErrorFault { return smithy.FaultServer }
// The request could not be completed due to throttling.
type ThrottlingException struct {
Message *string
ErrorCodeOverride *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 requested operation is not supported.
type UnsupportedOperationException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *UnsupportedOperationException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *UnsupportedOperationException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *UnsupportedOperationException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "UnsupportedOperationException"
}
return *e.ErrorCodeOverride
}
func (e *UnsupportedOperationException) ErrorFault() smithy.ErrorFault { return smithy.FaultServer }
| 246 |
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"
)
// Specifies whether to get notified for alarm state changes.
type AcknowledgeFlow struct {
// The value must be TRUE or FALSE . If TRUE , you receive a notification when the
// alarm state changes. You must choose to acknowledge the notification before the
// alarm state can return to NORMAL . If FALSE , you won't receive notifications.
// The alarm automatically changes to the NORMAL state when the input property
// value returns to the specified range.
//
// This member is required.
Enabled *bool
noSmithyDocumentSerde
}
// An action to be performed when the condition is TRUE.
type Action struct {
// Information needed to clear the timer.
ClearTimer *ClearTimerAction
// Writes to the DynamoDB table that you created. The default action payload
// contains all attribute-value pairs that have the information about the detector
// model instance and the event that triggered the action. You can customize the
// payload (https://docs.aws.amazon.com/iotevents/latest/apireference/API_Payload.html)
// . One column of the DynamoDB table receives all attribute-value pairs in the
// payload that you specify. For more information, see Actions (https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-event-actions.html)
// in AWS IoT Events Developer Guide.
DynamoDB *DynamoDBAction
// Writes to the DynamoDB table that you created. The default action payload
// contains all attribute-value pairs that have the information about the detector
// model instance and the event that triggered the action. You can customize the
// payload (https://docs.aws.amazon.com/iotevents/latest/apireference/API_Payload.html)
// . A separate column of the DynamoDB table receives one attribute-value pair in
// the payload that you specify. For more information, see Actions (https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-event-actions.html)
// in AWS IoT Events Developer Guide.
DynamoDBv2 *DynamoDBv2Action
// Sends information about the detector model instance and the event that
// triggered the action to an Amazon Kinesis Data Firehose delivery stream.
Firehose *FirehoseAction
// Sends AWS IoT Events input, which passes information about the detector model
// instance and the event that triggered the action.
IotEvents *IotEventsAction
// Sends information about the detector model instance and the event that
// triggered the action to an asset property in AWS IoT SiteWise .
IotSiteWise *IotSiteWiseAction
// Publishes an MQTT message with the given topic to the AWS IoT message broker.
IotTopicPublish *IotTopicPublishAction
// Calls a Lambda function, passing in information about the detector model
// instance and the event that triggered the action.
Lambda *LambdaAction
// Information needed to reset the timer.
ResetTimer *ResetTimerAction
// Information needed to set the timer.
SetTimer *SetTimerAction
// Sets a variable to a specified value.
SetVariable *SetVariableAction
// Sends an Amazon SNS message.
Sns *SNSTopicPublishAction
// Sends information about the detector model instance and the event that
// triggered the action to an Amazon SQS queue.
Sqs *SqsAction
noSmithyDocumentSerde
}
// Specifies one of the following actions to receive notifications when the alarm
// state changes.
type AlarmAction struct {
// Defines an action to write to the Amazon DynamoDB table that you created. The
// standard action payload contains all the information about the detector model
// instance and the event that triggered the action. You can customize the payload (https://docs.aws.amazon.com/iotevents/latest/apireference/API_Payload.html)
// . One column of the DynamoDB table receives all attribute-value pairs in the
// payload that you specify. You must use expressions for all parameters in
// DynamoDBAction . The expressions accept literals, operators, functions,
// references, and substitution templates. Examples
// - For literal values, the expressions must contain single quotes. For
// example, the value for the hashKeyType parameter can be 'STRING' .
// - For references, you must specify either variables or input values. For
// example, the value for the hashKeyField parameter can be
// $input.GreenhouseInput.name .
// - For a substitution template, you must use ${} , and the template must be in
// single quotes. A substitution template can also contain a combination of
// literals, operators, functions, references, and substitution templates. In the
// following example, the value for the hashKeyValue parameter uses a
// substitution template. '${$input.GreenhouseInput.temperature * 6 / 5 + 32}
// in Fahrenheit'
// - For a string concatenation, you must use + . A string concatenation can also
// contain a combination of literals, operators, functions, references, and
// substitution templates. In the following example, the value for the tableName
// parameter uses a string concatenation. 'GreenhouseTemperatureTable ' +
// $input.GreenhouseInput.date
// For more information, see Expressions (https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-expressions.html)
// in the AWS IoT Events Developer Guide. If the defined payload type is a string,
// DynamoDBAction writes non-JSON data to the DynamoDB table as binary data. The
// DynamoDB console displays the data as Base64-encoded text. The value for the
// payloadField parameter is _raw .
DynamoDB *DynamoDBAction
// Defines an action to write to the Amazon DynamoDB table that you created. The
// default action payload contains all the information about the detector model
// instance and the event that triggered the action. You can customize the payload (https://docs.aws.amazon.com/iotevents/latest/apireference/API_Payload.html)
// . A separate column of the DynamoDB table receives one attribute-value pair in
// the payload that you specify. You must use expressions for all parameters in
// DynamoDBv2Action . The expressions accept literals, operators, functions,
// references, and substitution templates. Examples
// - For literal values, the expressions must contain single quotes. For
// example, the value for the tableName parameter can be
// 'GreenhouseTemperatureTable' .
// - For references, you must specify either variables or input values. For
// example, the value for the tableName parameter can be $variable.ddbtableName .
// - For a substitution template, you must use ${} , and the template must be in
// single quotes. A substitution template can also contain a combination of
// literals, operators, functions, references, and substitution templates. In the
// following example, the value for the contentExpression parameter in Payload
// uses a substitution template. '{\"sensorID\":
// \"${$input.GreenhouseInput.sensor_id}\", \"temperature\":
// \"${$input.GreenhouseInput.temperature * 9 / 5 + 32}\"}'
// - For a string concatenation, you must use + . A string concatenation can also
// contain a combination of literals, operators, functions, references, and
// substitution templates. In the following example, the value for the tableName
// parameter uses a string concatenation. 'GreenhouseTemperatureTable ' +
// $input.GreenhouseInput.date
// For more information, see Expressions (https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-expressions.html)
// in the AWS IoT Events Developer Guide. The value for the type parameter in
// Payload must be JSON .
DynamoDBv2 *DynamoDBv2Action
// Sends information about the detector model instance and the event that
// triggered the action to an Amazon Kinesis Data Firehose delivery stream.
Firehose *FirehoseAction
// Sends an AWS IoT Events input, passing in information about the detector model
// instance and the event that triggered the action.
IotEvents *IotEventsAction
// Sends information about the detector model instance and the event that
// triggered the action to a specified asset property in AWS IoT SiteWise. You must
// use expressions for all parameters in IotSiteWiseAction . The expressions accept
// literals, operators, functions, references, and substitutions templates.
// Examples
// - For literal values, the expressions must contain single quotes. For
// example, the value for the propertyAlias parameter can be
// '/company/windfarm/3/turbine/7/temperature' .
// - For references, you must specify either variables or input values. For
// example, the value for the assetId parameter can be
// $input.TurbineInput.assetId1 .
// - For a substitution template, you must use ${} , and the template must be in
// single quotes. A substitution template can also contain a combination of
// literals, operators, functions, references, and substitution templates. In the
// following example, the value for the propertyAlias parameter uses a
// substitution template.
// 'company/windfarm/${$input.TemperatureInput.sensorData.windfarmID}/turbine/
// ${$input.TemperatureInput.sensorData.turbineID}/temperature'
// You must specify either propertyAlias or both assetId and propertyId to
// identify the target asset property in AWS IoT SiteWise. For more information,
// see Expressions (https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-expressions.html)
// in the AWS IoT Events Developer Guide.
IotSiteWise *IotSiteWiseAction
// Information required to publish the MQTT message through the AWS IoT message
// broker.
IotTopicPublish *IotTopicPublishAction
// Calls a Lambda function, passing in information about the detector model
// instance and the event that triggered the action.
Lambda *LambdaAction
// Information required to publish the Amazon SNS message.
Sns *SNSTopicPublishAction
// Sends information about the detector model instance and the event that
// triggered the action to an Amazon SQS queue.
Sqs *SqsAction
noSmithyDocumentSerde
}
// Contains the configuration information of alarm state changes.
type AlarmCapabilities struct {
// Specifies whether to get notified for alarm state changes.
AcknowledgeFlow *AcknowledgeFlow
// Specifies the default alarm state. The configuration applies to all alarms that
// were created based on this alarm model.
InitializationConfiguration *InitializationConfiguration
noSmithyDocumentSerde
}
// Contains information about one or more alarm actions.
type AlarmEventActions struct {
// Specifies one or more supported actions to receive notifications when the alarm
// state changes.
AlarmActions []AlarmAction
noSmithyDocumentSerde
}
// Contains a summary of an alarm model.
type AlarmModelSummary struct {
// The description of the alarm model.
AlarmModelDescription *string
// The name of the alarm model.
AlarmModelName *string
// The time the alarm model was created, in the Unix epoch format.
CreationTime *time.Time
noSmithyDocumentSerde
}
// Contains a summary of an alarm model version.
type AlarmModelVersionSummary struct {
// The ARN of the alarm model. For more information, see Amazon Resource Names
// (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
// in the AWS General Reference.
AlarmModelArn *string
// The name of the alarm model.
AlarmModelName *string
// The version of the alarm model.
AlarmModelVersion *string
// The time the alarm model was created, in the Unix epoch format.
CreationTime *time.Time
// The time the alarm model was last updated, in the Unix epoch format.
LastUpdateTime *time.Time
// The ARN of the IAM role that allows the alarm to perform actions and access AWS
// resources. For more information, see Amazon Resource Names (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
// in the AWS General Reference.
RoleArn *string
// The status of the alarm model. The status can be one of the following values:
// - ACTIVE - The alarm model is active and it's ready to evaluate data.
// - ACTIVATING - AWS IoT Events is activating your alarm model. Activating an
// alarm model can take up to a few minutes.
// - INACTIVE - The alarm model is inactive, so it isn't ready to evaluate data.
// Check your alarm model information and update the alarm model.
// - FAILED - You couldn't create or update the alarm model. Check your alarm
// model information and try again.
Status AlarmModelVersionStatus
// Contains information about the status of the alarm model version.
StatusMessage *string
noSmithyDocumentSerde
}
// Contains information about one or more notification actions.
type AlarmNotification struct {
// Contains the notification settings of an alarm model. The settings apply to all
// alarms that were created based on this alarm model.
NotificationActions []NotificationAction
noSmithyDocumentSerde
}
// Defines when your alarm is invoked.
type AlarmRule struct {
// A rule that compares an input property value to a threshold value with a
// comparison operator.
SimpleRule *SimpleRule
noSmithyDocumentSerde
}
// Contains the result of the analysis.
type AnalysisResult struct {
// The severity level of the analysis result. Based on the severity level,
// analysis results fall into three general categories:
// - INFO - An information result tells you about a significant field in your
// detector model. This type of result usually doesn't require immediate action.
// - WARNING - A warning result draws special attention to fields that might
// cause issues for your detector model. We recommend that you review warnings and
// take necessary actions before you use your detector model in production
// environments. Otherwise, the detector model might not work as expected.
// - ERROR - An error result notifies you about a problem found in your detector
// model. You must fix all errors before you can publish your detector model.
Level AnalysisResultLevel
// Contains one or more locations that you can use to locate the fields in your
// detector model that the analysis result references.
Locations []AnalysisResultLocation
// Contains additional information about the analysis result.
Message *string
// The type of the analysis result. Analyses fall into the following types based
// on the validators used to generate the analysis result:
// - supported-actions - You must specify AWS IoT Events supported actions that
// work with other AWS services in a supported AWS Region.
// - service-limits - Resources or API operations can't exceed service quotas
// (also known as limits). Update your detector model or request a quota increase.
// - structure - The detector model must follow a structure that AWS IoT Events
// supports.
// - expression-syntax - Your expression must follow the required syntax.
// - data-type - Data types referenced in the detector model must be compatible.
// - referenced-data - You must define the data referenced in your detector model
// before you can use the data.
// - referenced-resource - Resources that the detector model uses must be
// available.
// For more information, see Running detector model analyses (https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-analyze-api.html)
// in the AWS IoT Events Developer Guide.
Type *string
noSmithyDocumentSerde
}
// Contains information that you can use to locate the field in your detector
// model that the analysis result references.
type AnalysisResultLocation struct {
// A JsonPath (https://github.com/json-path/JsonPath) expression that identifies
// the error field in your detector model.
Path *string
noSmithyDocumentSerde
}
// A structure that contains timestamp information. For more information, see
// TimeInNanos (https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_TimeInNanos.html)
// in the AWS IoT SiteWise API Reference. You must use expressions for all
// parameters in AssetPropertyTimestamp . The expressions accept literals,
// operators, functions, references, and substitution templates. Examples
// - For literal values, the expressions must contain single quotes. For
// example, the value for the timeInSeconds parameter can be '1586400675' .
// - For references, you must specify either variables or input values. For
// example, the value for the offsetInNanos parameter can be $variable.time .
// - For a substitution template, you must use ${} , and the template must be in
// single quotes. A substitution template can also contain a combination of
// literals, operators, functions, references, and substitution templates. In the
// following example, the value for the timeInSeconds parameter uses a
// substitution template. '${$input.TemperatureInput.sensorData.timestamp /
// 1000}'
//
// For more information, see Expressions (https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-expressions.html)
// in the AWS IoT Events Developer Guide.
type AssetPropertyTimestamp struct {
// The timestamp, in seconds, in the Unix epoch format. The valid range is between
// 1-31556889864403199.
//
// This member is required.
TimeInSeconds *string
// The nanosecond offset converted from timeInSeconds . The valid range is between
// 0-999999999.
OffsetInNanos *string
noSmithyDocumentSerde
}
// A structure that contains value information. For more information, see
// AssetPropertyValue (https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_AssetPropertyValue.html)
// in the AWS IoT SiteWise API Reference. You must use expressions for all
// parameters in AssetPropertyValue . The expressions accept literals, operators,
// functions, references, and substitution templates. Examples
// - For literal values, the expressions must contain single quotes. For
// example, the value for the quality parameter can be 'GOOD' .
// - For references, you must specify either variables or input values. For
// example, the value for the quality parameter can be
// $input.TemperatureInput.sensorData.quality .
//
// For more information, see Expressions (https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-expressions.html)
// in the AWS IoT Events Developer Guide.
type AssetPropertyValue struct {
// The quality of the asset property value. The value must be 'GOOD' , 'BAD' , or
// 'UNCERTAIN' .
Quality *string
// The timestamp associated with the asset property value. The default is the
// current event time.
Timestamp *AssetPropertyTimestamp
// The value to send to an asset property.
Value *AssetPropertyVariant
noSmithyDocumentSerde
}
// A structure that contains an asset property value. For more information, see
// Variant (https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_Variant.html)
// in the AWS IoT SiteWise API Reference. You must use expressions for all
// parameters in AssetPropertyVariant . The expressions accept literals, operators,
// functions, references, and substitution templates. Examples
// - For literal values, the expressions must contain single quotes. For
// example, the value for the integerValue parameter can be '100' .
// - For references, you must specify either variables or parameters. For
// example, the value for the booleanValue parameter can be $variable.offline .
// - For a substitution template, you must use ${} , and the template must be in
// single quotes. A substitution template can also contain a combination of
// literals, operators, functions, references, and substitution templates. In the
// following example, the value for the doubleValue parameter uses a substitution
// template. '${$input.TemperatureInput.sensorData.temperature * 6 / 5 + 32}'
//
// For more information, see Expressions (https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-expressions.html)
// in the AWS IoT Events Developer Guide. You must specify one of the following
// value types, depending on the dataType of the specified asset property. For
// more information, see AssetProperty (https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_AssetProperty.html)
// in the AWS IoT SiteWise API Reference.
type AssetPropertyVariant struct {
// The asset property value is a Boolean value that must be 'TRUE' or 'FALSE' . You
// must use an expression, and the evaluated result should be a Boolean value.
BooleanValue *string
// The asset property value is a double. You must use an expression, and the
// evaluated result should be a double.
DoubleValue *string
// The asset property value is an integer. You must use an expression, and the
// evaluated result should be an integer.
IntegerValue *string
// The asset property value is a string. You must use an expression, and the
// evaluated result should be a string.
StringValue *string
noSmithyDocumentSerde
}
// The attributes from the JSON payload that are made available by the input.
// Inputs are derived from messages sent to the AWS IoT Events system using
// BatchPutMessage . Each such message contains a JSON payload. Those attributes
// (and their paired values) specified here are available for use in the condition
// expressions used by detectors.
type Attribute struct {
// An expression that specifies an attribute-value pair in a JSON structure. Use
// this to specify an attribute from the JSON payload that is made available by the
// input. Inputs are derived from messages sent to AWS IoT Events ( BatchPutMessage
// ). Each such message contains a JSON payload. The attribute (and its paired
// value) specified here are available for use in the condition expressions used
// by detectors. Syntax: ....
//
// This member is required.
JsonPath *string
noSmithyDocumentSerde
}
// Information needed to clear the timer.
type ClearTimerAction struct {
// The name of the timer to clear.
//
// This member is required.
TimerName *string
noSmithyDocumentSerde
}
// The detector model and the specific detectors (instances) for which the logging
// level is given.
type DetectorDebugOption struct {
// The name of the detector model.
//
// This member is required.
DetectorModelName *string
// The value of the input attribute key used to create the detector (the instance
// of the detector model).
KeyValue *string
noSmithyDocumentSerde
}
// Information about the detector model.
type DetectorModel struct {
// Information about how the detector is configured.
DetectorModelConfiguration *DetectorModelConfiguration
// Information that defines how a detector operates.
DetectorModelDefinition *DetectorModelDefinition
noSmithyDocumentSerde
}
// Information about how the detector model is configured.
type DetectorModelConfiguration struct {
// The time the detector model was created.
CreationTime *time.Time
// The ARN of the detector model.
DetectorModelArn *string
// A brief description of the detector model.
DetectorModelDescription *string
// The name of the detector model.
DetectorModelName *string
// The version of the detector model.
DetectorModelVersion *string
// Information about the order in which events are evaluated and how actions are
// executed.
EvaluationMethod EvaluationMethod
// The value used to identify a detector instance. When a device or system sends
// input, a new detector instance with a unique key value is created. AWS IoT
// Events can continue to route input to its corresponding detector instance based
// on this identifying information. This parameter uses a JSON-path expression to
// select the attribute-value pair in the message payload that is used for
// identification. To route the message to the correct detector instance, the
// device must send a message payload that contains the same attribute-value.
Key *string
// The time the detector model was last updated.
LastUpdateTime *time.Time
// The ARN of the role that grants permission to AWS IoT Events to perform its
// operations.
RoleArn *string
// The status of the detector model.
Status DetectorModelVersionStatus
noSmithyDocumentSerde
}
// Information that defines how a detector operates.
type DetectorModelDefinition struct {
// The state that is entered at the creation of each detector (instance).
//
// This member is required.
InitialStateName *string
// Information about the states of the detector.
//
// This member is required.
States []State
noSmithyDocumentSerde
}
// Information about the detector model.
type DetectorModelSummary struct {
// The time the detector model was created.
CreationTime *time.Time
// A brief description of the detector model.
DetectorModelDescription *string
// The name of the detector model.
DetectorModelName *string
noSmithyDocumentSerde
}
// Information about the detector model version.
type DetectorModelVersionSummary struct {
// The time the detector model version was created.
CreationTime *time.Time
// The ARN of the detector model version.
DetectorModelArn *string
// The name of the detector model.
DetectorModelName *string
// The ID of the detector model version.
DetectorModelVersion *string
// Information about the order in which events are evaluated and how actions are
// executed.
EvaluationMethod EvaluationMethod
// The last time the detector model version was updated.
LastUpdateTime *time.Time
// The ARN of the role that grants the detector model permission to perform its
// tasks.
RoleArn *string
// The status of the detector model version.
Status DetectorModelVersionStatus
noSmithyDocumentSerde
}
// Defines an action to write to the Amazon DynamoDB table that you created. The
// standard action payload contains all the information about the detector model
// instance and the event that triggered the action. You can customize the payload (https://docs.aws.amazon.com/iotevents/latest/apireference/API_Payload.html)
// . One column of the DynamoDB table receives all attribute-value pairs in the
// payload that you specify. You must use expressions for all parameters in
// DynamoDBAction . The expressions accept literals, operators, functions,
// references, and substitution templates. Examples
// - For literal values, the expressions must contain single quotes. For
// example, the value for the hashKeyType parameter can be 'STRING' .
// - For references, you must specify either variables or input values. For
// example, the value for the hashKeyField parameter can be
// $input.GreenhouseInput.name .
// - For a substitution template, you must use ${} , and the template must be in
// single quotes. A substitution template can also contain a combination of
// literals, operators, functions, references, and substitution templates. In the
// following example, the value for the hashKeyValue parameter uses a
// substitution template. '${$input.GreenhouseInput.temperature * 6 / 5 + 32}
// in Fahrenheit'
// - For a string concatenation, you must use + . A string concatenation can also
// contain a combination of literals, operators, functions, references, and
// substitution templates. In the following example, the value for the tableName
// parameter uses a string concatenation. 'GreenhouseTemperatureTable ' +
// $input.GreenhouseInput.date
//
// For more information, see Expressions (https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-expressions.html)
// in the AWS IoT Events Developer Guide. If the defined payload type is a string,
// DynamoDBAction writes non-JSON data to the DynamoDB table as binary data. The
// DynamoDB console displays the data as Base64-encoded text. The value for the
// payloadField parameter is _raw .
type DynamoDBAction struct {
// The name of the hash key (also called the partition key). The hashKeyField
// value must match the partition key of the target DynamoDB table.
//
// This member is required.
HashKeyField *string
// The value of the hash key (also called the partition key).
//
// This member is required.
HashKeyValue *string
// The name of the DynamoDB table. The tableName value must match the table name
// of the target DynamoDB table.
//
// This member is required.
TableName *string
// The data type for the hash key (also called the partition key). You can specify
// the following values:
// - 'STRING' - The hash key is a string.
// - 'NUMBER' - The hash key is a number.
// If you don't specify hashKeyType , the default value is 'STRING' .
HashKeyType *string
// The type of operation to perform. You can specify the following values:
// - 'INSERT' - Insert data as a new item into the DynamoDB table. This item uses
// the specified hash key as a partition key. If you specified a range key, the
// item uses the range key as a sort key.
// - 'UPDATE' - Update an existing item of the DynamoDB table with new data. This
// item's partition key must match the specified hash key. If you specified a range
// key, the range key must match the item's sort key.
// - 'DELETE' - Delete an existing item of the DynamoDB table. This item's
// partition key must match the specified hash key. If you specified a range key,
// the range key must match the item's sort key.
// If you don't specify this parameter, AWS IoT Events triggers the 'INSERT'
// operation.
Operation *string
// Information needed to configure the payload. By default, AWS IoT Events
// generates a standard payload in JSON for any action. This action payload
// contains all attribute-value pairs that have the information about the detector
// model instance and the event triggered the action. To configure the action
// payload, you can use contentExpression .
Payload *Payload
// The name of the DynamoDB column that receives the action payload. If you don't
// specify this parameter, the name of the DynamoDB column is payload .
PayloadField *string
// The name of the range key (also called the sort key). The rangeKeyField value
// must match the sort key of the target DynamoDB table.
RangeKeyField *string
// The data type for the range key (also called the sort key), You can specify the
// following values:
// - 'STRING' - The range key is a string.
// - 'NUMBER' - The range key is number.
// If you don't specify rangeKeyField , the default value is 'STRING' .
RangeKeyType *string
// The value of the range key (also called the sort key).
RangeKeyValue *string
noSmithyDocumentSerde
}
// Defines an action to write to the Amazon DynamoDB table that you created. The
// default action payload contains all the information about the detector model
// instance and the event that triggered the action. You can customize the payload (https://docs.aws.amazon.com/iotevents/latest/apireference/API_Payload.html)
// . A separate column of the DynamoDB table receives one attribute-value pair in
// the payload that you specify. You must use expressions for all parameters in
// DynamoDBv2Action . The expressions accept literals, operators, functions,
// references, and substitution templates. Examples
// - For literal values, the expressions must contain single quotes. For
// example, the value for the tableName parameter can be
// 'GreenhouseTemperatureTable' .
// - For references, you must specify either variables or input values. For
// example, the value for the tableName parameter can be $variable.ddbtableName .
// - For a substitution template, you must use ${} , and the template must be in
// single quotes. A substitution template can also contain a combination of
// literals, operators, functions, references, and substitution templates. In the
// following example, the value for the contentExpression parameter in Payload
// uses a substitution template. '{\"sensorID\":
// \"${$input.GreenhouseInput.sensor_id}\", \"temperature\":
// \"${$input.GreenhouseInput.temperature * 9 / 5 + 32}\"}'
// - For a string concatenation, you must use + . A string concatenation can also
// contain a combination of literals, operators, functions, references, and
// substitution templates. In the following example, the value for the tableName
// parameter uses a string concatenation. 'GreenhouseTemperatureTable ' +
// $input.GreenhouseInput.date
//
// For more information, see Expressions (https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-expressions.html)
// in the AWS IoT Events Developer Guide. The value for the type parameter in
// Payload must be JSON .
type DynamoDBv2Action struct {
// The name of the DynamoDB table.
//
// This member is required.
TableName *string
// Information needed to configure the payload. By default, AWS IoT Events
// generates a standard payload in JSON for any action. This action payload
// contains all attribute-value pairs that have the information about the detector
// model instance and the event triggered the action. To configure the action
// payload, you can use contentExpression .
Payload *Payload
noSmithyDocumentSerde
}
// Contains the configuration information of email notifications.
type EmailConfiguration struct {
// The email address that sends emails. If you use the AWS IoT Events managed AWS
// Lambda function to manage your emails, you must verify the email address that
// sends emails in Amazon SES (https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-email-addresses.html)
// .
//
// This member is required.
From *string
// Contains the information of one or more recipients who receive the emails. You
// must add the users that receive emails to your AWS SSO store (https://docs.aws.amazon.com/singlesignon/latest/userguide/addusers.html)
// .
//
// This member is required.
Recipients *EmailRecipients
// Contains the subject and message of an email.
Content *EmailContent
noSmithyDocumentSerde
}
// Contains the subject and message of an email.
type EmailContent struct {
// The message that you want to send. The message can be up to 200 characters.
AdditionalMessage *string
// The subject of the email.
Subject *string
noSmithyDocumentSerde
}
// Contains the information of one or more recipients who receive the emails. You
// must add the users that receive emails to your AWS SSO store (https://docs.aws.amazon.com/singlesignon/latest/userguide/addusers.html)
// .
type EmailRecipients struct {
// Specifies one or more recipients who receive the email.
To []RecipientDetail
noSmithyDocumentSerde
}
// Specifies the actions to be performed when the condition evaluates to TRUE.
type Event struct {
// The name of the event.
//
// This member is required.
EventName *string
// The actions to be performed.
Actions []Action
// Optional. The Boolean expression that, when TRUE, causes the actions to be
// performed. If not present, the actions are performed (=TRUE). If the expression
// result is not a Boolean value, the actions are not performed (=FALSE).
Condition *string
noSmithyDocumentSerde
}
// Sends information about the detector model instance and the event that
// triggered the action to an Amazon Kinesis Data Firehose delivery stream.
type FirehoseAction struct {
// The name of the Kinesis Data Firehose delivery stream where the data is written.
//
// This member is required.
DeliveryStreamName *string
// You can configure the action payload when you send a message to an Amazon
// Kinesis Data Firehose delivery stream.
Payload *Payload
// A character separator that is used to separate records written to the Kinesis
// Data Firehose delivery stream. Valid values are: '\n' (newline), '\t' (tab),
// '\r\n' (Windows newline), ',' (comma).
Separator *string
noSmithyDocumentSerde
}
// Specifies the default alarm state. The configuration applies to all alarms that
// were created based on this alarm model.
type InitializationConfiguration struct {
// The value must be TRUE or FALSE . If FALSE , all alarm instances created based
// on the alarm model are activated. The default value is TRUE .
//
// This member is required.
DisabledOnInitialization *bool
noSmithyDocumentSerde
}
// Information about the input.
type Input struct {
// Information about the configuration of an input.
InputConfiguration *InputConfiguration
// The definition of the input.
InputDefinition *InputDefinition
noSmithyDocumentSerde
}
// Information about the configuration of an input.
type InputConfiguration struct {
// The time the input was created.
//
// This member is required.
CreationTime *time.Time
// The ARN of the input.
//
// This member is required.
InputArn *string
// The name of the input.
//
// This member is required.
InputName *string
// The last time the input was updated.
//
// This member is required.
LastUpdateTime *time.Time
// The status of the input.
//
// This member is required.
Status InputStatus
// A brief description of the input.
InputDescription *string
noSmithyDocumentSerde
}
// The definition of the input.
type InputDefinition struct {
// The attributes from the JSON payload that are made available by the input.
// Inputs are derived from messages sent to the AWS IoT Events system using
// BatchPutMessage . Each such message contains a JSON payload, and those
// attributes (and their paired values) specified here are available for use in the
// condition expressions used by detectors that monitor this input.
//
// This member is required.
Attributes []Attribute
noSmithyDocumentSerde
}
// The identifer of the input.
type InputIdentifier struct {
// The identifier of the input routed to AWS IoT Events.
IotEventsInputIdentifier *IotEventsInputIdentifier
// The identifer of the input routed from AWS IoT SiteWise.
IotSiteWiseInputIdentifier *IotSiteWiseInputIdentifier
noSmithyDocumentSerde
}
// Information about the input.
type InputSummary struct {
// The time the input was created.
CreationTime *time.Time
// The ARN of the input.
InputArn *string
// A brief description of the input.
InputDescription *string
// The name of the input.
InputName *string
// The last time the input was updated.
LastUpdateTime *time.Time
// The status of the input.
Status InputStatus
noSmithyDocumentSerde
}
// Sends an AWS IoT Events input, passing in information about the detector model
// instance and the event that triggered the action.
type IotEventsAction struct {
// The name of the AWS IoT Events input where the data is sent.
//
// This member is required.
InputName *string
// You can configure the action payload when you send a message to an AWS IoT
// Events input.
Payload *Payload
noSmithyDocumentSerde
}
// The identifier of the input routed to AWS IoT Events.
type IotEventsInputIdentifier struct {
// The name of the input routed to AWS IoT Events.
//
// This member is required.
InputName *string
noSmithyDocumentSerde
}
// Sends information about the detector model instance and the event that
// triggered the action to a specified asset property in AWS IoT SiteWise. You must
// use expressions for all parameters in IotSiteWiseAction . The expressions accept
// literals, operators, functions, references, and substitutions templates.
// Examples
// - For literal values, the expressions must contain single quotes. For
// example, the value for the propertyAlias parameter can be
// '/company/windfarm/3/turbine/7/temperature' .
// - For references, you must specify either variables or input values. For
// example, the value for the assetId parameter can be
// $input.TurbineInput.assetId1 .
// - For a substitution template, you must use ${} , and the template must be in
// single quotes. A substitution template can also contain a combination of
// literals, operators, functions, references, and substitution templates. In the
// following example, the value for the propertyAlias parameter uses a
// substitution template.
// 'company/windfarm/${$input.TemperatureInput.sensorData.windfarmID}/turbine/
// ${$input.TemperatureInput.sensorData.turbineID}/temperature'
//
// You must specify either propertyAlias or both assetId and propertyId to
// identify the target asset property in AWS IoT SiteWise. For more information,
// see Expressions (https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-expressions.html)
// in the AWS IoT Events Developer Guide.
type IotSiteWiseAction struct {
// The ID of the asset that has the specified property.
AssetId *string
// A unique identifier for this entry. You can use the entry ID to track which
// data entry causes an error in case of failure. The default is a new unique
// identifier.
EntryId *string
// The alias of the asset property.
PropertyAlias *string
// The ID of the asset property.
PropertyId *string
// The value to send to the asset property. This value contains timestamp,
// quality, and value (TQV) information.
PropertyValue *AssetPropertyValue
noSmithyDocumentSerde
}
// The asset model property identifer of the input routed from AWS IoT SiteWise.
type IotSiteWiseAssetModelPropertyIdentifier struct {
// The ID of the AWS IoT SiteWise asset model.
//
// This member is required.
AssetModelId *string
// The ID of the AWS IoT SiteWise asset property.
//
// This member is required.
PropertyId *string
noSmithyDocumentSerde
}
// The identifer of the input routed from AWS IoT SiteWise.
type IotSiteWiseInputIdentifier struct {
// The identifier of the AWS IoT SiteWise asset model property.
IotSiteWiseAssetModelPropertyIdentifier *IotSiteWiseAssetModelPropertyIdentifier
noSmithyDocumentSerde
}
// Information required to publish the MQTT message through the AWS IoT message
// broker.
type IotTopicPublishAction struct {
// The MQTT topic of the message. You can use a string expression that includes
// variables ( $variable. ) and input values ( $input.. ) as the topic string.
//
// This member is required.
MqttTopic *string
// You can configure the action payload when you publish a message to an AWS IoT
// Core topic.
Payload *Payload
noSmithyDocumentSerde
}
// Calls a Lambda function, passing in information about the detector model
// instance and the event that triggered the action.
type LambdaAction struct {
// The ARN of the Lambda function that is executed.
//
// This member is required.
FunctionArn *string
// You can configure the action payload when you send a message to a Lambda
// function.
Payload *Payload
noSmithyDocumentSerde
}
// The values of the AWS IoT Events logging options.
type LoggingOptions struct {
// If TRUE, logging is enabled for AWS IoT Events.
//
// This member is required.
Enabled bool
// The logging level.
//
// This member is required.
Level LoggingLevel
// The ARN of the role that grants permission to AWS IoT Events to perform logging.
//
// This member is required.
RoleArn *string
// Information that identifies those detector models and their detectors
// (instances) for which the logging level is given.
DetectorDebugOptions []DetectorDebugOption
noSmithyDocumentSerde
}
// Contains the notification settings of an alarm model. The settings apply to all
// alarms that were created based on this alarm model.
type NotificationAction struct {
// Specifies an AWS Lambda function to manage alarm notifications. You can create
// one or use the AWS Lambda function provided by AWS IoT Events (https://docs.aws.amazon.com/iotevents/latest/developerguide/lambda-support.html)
// .
//
// This member is required.
Action *NotificationTargetActions
// Contains the configuration information of email notifications.
EmailConfigurations []EmailConfiguration
// Contains the configuration information of SMS notifications.
SmsConfigurations []SMSConfiguration
noSmithyDocumentSerde
}
// Specifies an AWS Lambda function to manage alarm notifications. You can create
// one or use the AWS Lambda function provided by AWS IoT Events (https://docs.aws.amazon.com/iotevents/latest/developerguide/lambda-support.html)
// .
type NotificationTargetActions struct {
// Calls a Lambda function, passing in information about the detector model
// instance and the event that triggered the action.
LambdaAction *LambdaAction
noSmithyDocumentSerde
}
// When entering this state, perform these actions if the condition is TRUE.
type OnEnterLifecycle struct {
// Specifies the actions that are performed when the state is entered and the
// condition is TRUE .
Events []Event
noSmithyDocumentSerde
}
// When exiting this state, perform these actions if the specified condition is
// TRUE .
type OnExitLifecycle struct {
// Specifies the actions that are performed when the state is exited and the
// condition is TRUE .
Events []Event
noSmithyDocumentSerde
}
// Specifies the actions performed when the condition evaluates to TRUE.
type OnInputLifecycle struct {
// Specifies the actions performed when the condition evaluates to TRUE.
Events []Event
// Specifies the actions performed, and the next state entered, when a condition
// evaluates to TRUE.
TransitionEvents []TransitionEvent
noSmithyDocumentSerde
}
// Information needed to configure the payload. By default, AWS IoT Events
// generates a standard payload in JSON for any action. This action payload
// contains all attribute-value pairs that have the information about the detector
// model instance and the event triggered the action. To configure the action
// payload, you can use contentExpression .
type Payload struct {
// The content of the payload. You can use a string expression that includes
// quoted strings ( '' ), variables ( $variable. ), input values ( $input.. ),
// string concatenations, and quoted strings that contain ${} as the content. The
// recommended maximum size of a content expression is 1 KB.
//
// This member is required.
ContentExpression *string
// The value of the payload type can be either STRING or JSON .
//
// This member is required.
Type PayloadType
noSmithyDocumentSerde
}
// The information that identifies the recipient.
type RecipientDetail struct {
// The AWS Single Sign-On (AWS SSO) authentication information.
SsoIdentity *SSOIdentity
noSmithyDocumentSerde
}
// Information required to reset the timer. The timer is reset to the previously
// evaluated result of the duration. The duration expression isn't reevaluated when
// you reset the timer.
type ResetTimerAction struct {
// The name of the timer to reset.
//
// This member is required.
TimerName *string
noSmithyDocumentSerde
}
// Contains information about the routed resource.
type RoutedResource struct {
// The ARN of the routed resource. For more information, see Amazon Resource Names
// (ARNs) (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
// in the AWS General Reference.
Arn *string
// The name of the routed resource.
Name *string
noSmithyDocumentSerde
}
// Information needed to set the timer.
type SetTimerAction struct {
// The name of the timer.
//
// This member is required.
TimerName *string
// The duration of the timer, in seconds. You can use a string expression that
// includes numbers, variables ( $variable. ), and input values ( $input.. ) as the
// duration. The range of the duration is 1-31622400 seconds. To ensure accuracy,
// the minimum duration is 60 seconds. The evaluated result of the duration is
// rounded down to the nearest whole number.
DurationExpression *string
// The number of seconds until the timer expires. The minimum value is 60 seconds
// to ensure accuracy. The maximum value is 31622400 seconds.
//
// Deprecated: seconds is deprecated. You can use durationExpression for
// SetTimerAction. The value of seconds can be used as a string expression for
// durationExpression.
Seconds *int32
noSmithyDocumentSerde
}
// Information about the variable and its new value.
type SetVariableAction struct {
// The new value of the variable.
//
// This member is required.
Value *string
// The name of the variable.
//
// This member is required.
VariableName *string
noSmithyDocumentSerde
}
// A rule that compares an input property value to a threshold value with a
// comparison operator.
type SimpleRule struct {
// The comparison operator.
//
// This member is required.
ComparisonOperator ComparisonOperator
// The value on the left side of the comparison operator. You can specify an AWS
// IoT Events input attribute as an input property.
//
// This member is required.
InputProperty *string
// The value on the right side of the comparison operator. You can enter a number
// or specify an AWS IoT Events input attribute.
//
// This member is required.
Threshold *string
noSmithyDocumentSerde
}
// Contains the configuration information of SMS notifications.
type SMSConfiguration struct {
// Specifies one or more recipients who receive the message. You must add the
// users that receive SMS messages to your AWS SSO store (https://docs.aws.amazon.com/singlesignon/latest/userguide/addusers.html)
// .
//
// This member is required.
Recipients []RecipientDetail
// The message that you want to send. The message can be up to 200 characters.
AdditionalMessage *string
// The sender ID.
SenderId *string
noSmithyDocumentSerde
}
// Information required to publish the Amazon SNS message.
type SNSTopicPublishAction struct {
// The ARN of the Amazon SNS target where the message is sent.
//
// This member is required.
TargetArn *string
// You can configure the action payload when you send a message as an Amazon SNS
// push notification.
Payload *Payload
noSmithyDocumentSerde
}
// Sends information about the detector model instance and the event that
// triggered the action to an Amazon SQS queue.
type SqsAction struct {
// The URL of the SQS queue where the data is written.
//
// This member is required.
QueueUrl *string
// You can configure the action payload when you send a message to an Amazon SQS
// queue.
Payload *Payload
// Set this to TRUE if you want the data to be base-64 encoded before it is
// written to the queue. Otherwise, set this to FALSE.
UseBase64 *bool
noSmithyDocumentSerde
}
// Contains information about your identity source in AWS Single Sign-On. For more
// information, see the AWS Single Sign-On User Guide (https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html)
// .
type SSOIdentity struct {
// The ID of the AWS SSO identity store.
//
// This member is required.
IdentityStoreId *string
// The user ID.
UserId *string
noSmithyDocumentSerde
}
// Information that defines a state of a detector.
type State struct {
// The name of the state.
//
// This member is required.
StateName *string
// When entering this state, perform these actions if the condition is TRUE.
OnEnter *OnEnterLifecycle
// When exiting this state, perform these actions if the specified condition is
// TRUE .
OnExit *OnExitLifecycle
// When an input is received and the condition is TRUE, perform the specified
// actions .
OnInput *OnInputLifecycle
noSmithyDocumentSerde
}
// Metadata that can be used to manage the resource.
type Tag struct {
// The tag's key.
//
// This member is required.
Key *string
// The tag's value.
//
// This member is required.
Value *string
noSmithyDocumentSerde
}
// Specifies the actions performed and the next state entered when a condition
// evaluates to TRUE.
type TransitionEvent struct {
// Required. A Boolean expression that when TRUE causes the actions to be
// performed and the nextState to be entered.
//
// This member is required.
Condition *string
// The name of the transition event.
//
// This member is required.
EventName *string
// The next state to enter.
//
// This member is required.
NextState *string
// The actions to be performed.
Actions []Action
noSmithyDocumentSerde
}
type noSmithyDocumentSerde = smithydocument.NoSerde
| 1,443 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ioteventsdata
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 = "IoT Events Data"
const ServiceAPIVersion = "2018-10-23"
// Client provides the API client to make operations call for AWS IoT Events Data.
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, "ioteventsdata", 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)
}
| 434 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ioteventsdata
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 ioteventsdata
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/ioteventsdata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Acknowledges one or more alarms. The alarms change to the ACKNOWLEDGED state
// after you acknowledge them.
func (c *Client) BatchAcknowledgeAlarm(ctx context.Context, params *BatchAcknowledgeAlarmInput, optFns ...func(*Options)) (*BatchAcknowledgeAlarmOutput, error) {
if params == nil {
params = &BatchAcknowledgeAlarmInput{}
}
result, metadata, err := c.invokeOperation(ctx, "BatchAcknowledgeAlarm", params, optFns, c.addOperationBatchAcknowledgeAlarmMiddlewares)
if err != nil {
return nil, err
}
out := result.(*BatchAcknowledgeAlarmOutput)
out.ResultMetadata = metadata
return out, nil
}
type BatchAcknowledgeAlarmInput struct {
// The list of acknowledge action requests. You can specify up to 10 requests per
// operation.
//
// This member is required.
AcknowledgeActionRequests []types.AcknowledgeAlarmActionRequest
noSmithyDocumentSerde
}
type BatchAcknowledgeAlarmOutput struct {
// A list of errors associated with the request, or null if there are no errors.
// Each error entry contains an entry ID that helps you identify the entry that
// failed.
ErrorEntries []types.BatchAlarmActionErrorEntry
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationBatchAcknowledgeAlarmMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpBatchAcknowledgeAlarm{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpBatchAcknowledgeAlarm{}, 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 = addOpBatchAcknowledgeAlarmValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opBatchAcknowledgeAlarm(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_opBatchAcknowledgeAlarm(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ioteventsdata",
OperationName: "BatchAcknowledgeAlarm",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ioteventsdata
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/ioteventsdata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes one or more detectors that were created. When a detector is deleted,
// its state will be cleared and the detector will be removed from the list of
// detectors. The deleted detector will no longer appear if referenced in the
// ListDetectors (https://docs.aws.amazon.com/iotevents/latest/apireference/API_iotevents-data_ListDetectors.html)
// API call.
func (c *Client) BatchDeleteDetector(ctx context.Context, params *BatchDeleteDetectorInput, optFns ...func(*Options)) (*BatchDeleteDetectorOutput, error) {
if params == nil {
params = &BatchDeleteDetectorInput{}
}
result, metadata, err := c.invokeOperation(ctx, "BatchDeleteDetector", params, optFns, c.addOperationBatchDeleteDetectorMiddlewares)
if err != nil {
return nil, err
}
out := result.(*BatchDeleteDetectorOutput)
out.ResultMetadata = metadata
return out, nil
}
type BatchDeleteDetectorInput struct {
// The list of one or more detectors to be deleted.
//
// This member is required.
Detectors []types.DeleteDetectorRequest
noSmithyDocumentSerde
}
type BatchDeleteDetectorOutput struct {
// A list of errors associated with the request, or an empty array ( [] ) if there
// are no errors. Each error entry contains a messageId that helps you identify
// the entry that failed.
BatchDeleteDetectorErrorEntries []types.BatchDeleteDetectorErrorEntry
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationBatchDeleteDetectorMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpBatchDeleteDetector{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpBatchDeleteDetector{}, 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 = addOpBatchDeleteDetectorValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opBatchDeleteDetector(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_opBatchDeleteDetector(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ioteventsdata",
OperationName: "BatchDeleteDetector",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ioteventsdata
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/ioteventsdata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Disables one or more alarms. The alarms change to the DISABLED state after you
// disable them.
func (c *Client) BatchDisableAlarm(ctx context.Context, params *BatchDisableAlarmInput, optFns ...func(*Options)) (*BatchDisableAlarmOutput, error) {
if params == nil {
params = &BatchDisableAlarmInput{}
}
result, metadata, err := c.invokeOperation(ctx, "BatchDisableAlarm", params, optFns, c.addOperationBatchDisableAlarmMiddlewares)
if err != nil {
return nil, err
}
out := result.(*BatchDisableAlarmOutput)
out.ResultMetadata = metadata
return out, nil
}
type BatchDisableAlarmInput struct {
// The list of disable action requests. You can specify up to 10 requests per
// operation.
//
// This member is required.
DisableActionRequests []types.DisableAlarmActionRequest
noSmithyDocumentSerde
}
type BatchDisableAlarmOutput struct {
// A list of errors associated with the request, or null if there are no errors.
// Each error entry contains an entry ID that helps you identify the entry that
// failed.
ErrorEntries []types.BatchAlarmActionErrorEntry
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationBatchDisableAlarmMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpBatchDisableAlarm{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpBatchDisableAlarm{}, 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 = addOpBatchDisableAlarmValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opBatchDisableAlarm(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_opBatchDisableAlarm(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ioteventsdata",
OperationName: "BatchDisableAlarm",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ioteventsdata
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/ioteventsdata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Enables one or more alarms. The alarms change to the NORMAL state after you
// enable them.
func (c *Client) BatchEnableAlarm(ctx context.Context, params *BatchEnableAlarmInput, optFns ...func(*Options)) (*BatchEnableAlarmOutput, error) {
if params == nil {
params = &BatchEnableAlarmInput{}
}
result, metadata, err := c.invokeOperation(ctx, "BatchEnableAlarm", params, optFns, c.addOperationBatchEnableAlarmMiddlewares)
if err != nil {
return nil, err
}
out := result.(*BatchEnableAlarmOutput)
out.ResultMetadata = metadata
return out, nil
}
type BatchEnableAlarmInput struct {
// The list of enable action requests. You can specify up to 10 requests per
// operation.
//
// This member is required.
EnableActionRequests []types.EnableAlarmActionRequest
noSmithyDocumentSerde
}
type BatchEnableAlarmOutput struct {
// A list of errors associated with the request, or null if there are no errors.
// Each error entry contains an entry ID that helps you identify the entry that
// failed.
ErrorEntries []types.BatchAlarmActionErrorEntry
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationBatchEnableAlarmMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpBatchEnableAlarm{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpBatchEnableAlarm{}, 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 = addOpBatchEnableAlarmValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opBatchEnableAlarm(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_opBatchEnableAlarm(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ioteventsdata",
OperationName: "BatchEnableAlarm",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ioteventsdata
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/ioteventsdata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Sends a set of messages to the IoT Events system. Each message payload is
// transformed into the input you specify ( "inputName" ) and ingested into any
// detectors that monitor that input. If multiple messages are sent, the order in
// which the messages are processed isn't guaranteed. To guarantee ordering, you
// must send messages one at a time and wait for a successful response.
func (c *Client) BatchPutMessage(ctx context.Context, params *BatchPutMessageInput, optFns ...func(*Options)) (*BatchPutMessageOutput, error) {
if params == nil {
params = &BatchPutMessageInput{}
}
result, metadata, err := c.invokeOperation(ctx, "BatchPutMessage", params, optFns, c.addOperationBatchPutMessageMiddlewares)
if err != nil {
return nil, err
}
out := result.(*BatchPutMessageOutput)
out.ResultMetadata = metadata
return out, nil
}
type BatchPutMessageInput struct {
// The list of messages to send. Each message has the following format: '{
// "messageId": "string", "inputName": "string", "payload": "string"}'
//
// This member is required.
Messages []types.Message
noSmithyDocumentSerde
}
type BatchPutMessageOutput struct {
// A list of any errors encountered when sending the messages.
BatchPutMessageErrorEntries []types.BatchPutMessageErrorEntry
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationBatchPutMessageMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpBatchPutMessage{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpBatchPutMessage{}, 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 = addOpBatchPutMessageValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opBatchPutMessage(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_opBatchPutMessage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ioteventsdata",
OperationName: "BatchPutMessage",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ioteventsdata
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/ioteventsdata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Resets one or more alarms. The alarms return to the NORMAL state after you
// reset them.
func (c *Client) BatchResetAlarm(ctx context.Context, params *BatchResetAlarmInput, optFns ...func(*Options)) (*BatchResetAlarmOutput, error) {
if params == nil {
params = &BatchResetAlarmInput{}
}
result, metadata, err := c.invokeOperation(ctx, "BatchResetAlarm", params, optFns, c.addOperationBatchResetAlarmMiddlewares)
if err != nil {
return nil, err
}
out := result.(*BatchResetAlarmOutput)
out.ResultMetadata = metadata
return out, nil
}
type BatchResetAlarmInput struct {
// The list of reset action requests. You can specify up to 10 requests per
// operation.
//
// This member is required.
ResetActionRequests []types.ResetAlarmActionRequest
noSmithyDocumentSerde
}
type BatchResetAlarmOutput struct {
// A list of errors associated with the request, or null if there are no errors.
// Each error entry contains an entry ID that helps you identify the entry that
// failed.
ErrorEntries []types.BatchAlarmActionErrorEntry
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationBatchResetAlarmMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpBatchResetAlarm{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpBatchResetAlarm{}, 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 = addOpBatchResetAlarmValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opBatchResetAlarm(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_opBatchResetAlarm(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ioteventsdata",
OperationName: "BatchResetAlarm",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ioteventsdata
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/ioteventsdata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Changes one or more alarms to the snooze mode. The alarms change to the
// SNOOZE_DISABLED state after you set them to the snooze mode.
func (c *Client) BatchSnoozeAlarm(ctx context.Context, params *BatchSnoozeAlarmInput, optFns ...func(*Options)) (*BatchSnoozeAlarmOutput, error) {
if params == nil {
params = &BatchSnoozeAlarmInput{}
}
result, metadata, err := c.invokeOperation(ctx, "BatchSnoozeAlarm", params, optFns, c.addOperationBatchSnoozeAlarmMiddlewares)
if err != nil {
return nil, err
}
out := result.(*BatchSnoozeAlarmOutput)
out.ResultMetadata = metadata
return out, nil
}
type BatchSnoozeAlarmInput struct {
// The list of snooze action requests. You can specify up to 10 requests per
// operation.
//
// This member is required.
SnoozeActionRequests []types.SnoozeAlarmActionRequest
noSmithyDocumentSerde
}
type BatchSnoozeAlarmOutput struct {
// A list of errors associated with the request, or null if there are no errors.
// Each error entry contains an entry ID that helps you identify the entry that
// failed.
ErrorEntries []types.BatchAlarmActionErrorEntry
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationBatchSnoozeAlarmMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpBatchSnoozeAlarm{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpBatchSnoozeAlarm{}, 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 = addOpBatchSnoozeAlarmValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opBatchSnoozeAlarm(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_opBatchSnoozeAlarm(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ioteventsdata",
OperationName: "BatchSnoozeAlarm",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ioteventsdata
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/ioteventsdata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates the state, variable values, and timer settings of one or more detectors
// (instances) of a specified detector model.
func (c *Client) BatchUpdateDetector(ctx context.Context, params *BatchUpdateDetectorInput, optFns ...func(*Options)) (*BatchUpdateDetectorOutput, error) {
if params == nil {
params = &BatchUpdateDetectorInput{}
}
result, metadata, err := c.invokeOperation(ctx, "BatchUpdateDetector", params, optFns, c.addOperationBatchUpdateDetectorMiddlewares)
if err != nil {
return nil, err
}
out := result.(*BatchUpdateDetectorOutput)
out.ResultMetadata = metadata
return out, nil
}
type BatchUpdateDetectorInput struct {
// The list of detectors (instances) to update, along with the values to update.
//
// This member is required.
Detectors []types.UpdateDetectorRequest
noSmithyDocumentSerde
}
type BatchUpdateDetectorOutput struct {
// A list of those detector updates that resulted in errors. (If an error is
// listed here, the specific update did not occur.)
BatchUpdateDetectorErrorEntries []types.BatchUpdateDetectorErrorEntry
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationBatchUpdateDetectorMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpBatchUpdateDetector{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpBatchUpdateDetector{}, 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 = addOpBatchUpdateDetectorValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opBatchUpdateDetector(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_opBatchUpdateDetector(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ioteventsdata",
OperationName: "BatchUpdateDetector",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ioteventsdata
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/ioteventsdata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves information about an alarm.
func (c *Client) DescribeAlarm(ctx context.Context, params *DescribeAlarmInput, optFns ...func(*Options)) (*DescribeAlarmOutput, error) {
if params == nil {
params = &DescribeAlarmInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeAlarm", params, optFns, c.addOperationDescribeAlarmMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeAlarmOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeAlarmInput struct {
// The name of the alarm model.
//
// This member is required.
AlarmModelName *string
// The value of the key used as a filter to select only the alarms associated with
// the key (https://docs.aws.amazon.com/iotevents/latest/apireference/API_CreateAlarmModel.html#iotevents-CreateAlarmModel-request-key)
// .
KeyValue *string
noSmithyDocumentSerde
}
type DescribeAlarmOutput struct {
// Contains information about an alarm.
Alarm *types.Alarm
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeAlarmMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeAlarm{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeAlarm{}, 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 = addOpDescribeAlarmValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeAlarm(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_opDescribeAlarm(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ioteventsdata",
OperationName: "DescribeAlarm",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ioteventsdata
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/ioteventsdata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about the specified detector (instance).
func (c *Client) DescribeDetector(ctx context.Context, params *DescribeDetectorInput, optFns ...func(*Options)) (*DescribeDetectorOutput, error) {
if params == nil {
params = &DescribeDetectorInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDetector", params, optFns, c.addOperationDescribeDetectorMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDetectorOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDetectorInput struct {
// The name of the detector model whose detectors (instances) you want information
// about.
//
// This member is required.
DetectorModelName *string
// A filter used to limit results to detectors (instances) created because of the
// given key ID.
KeyValue *string
noSmithyDocumentSerde
}
type DescribeDetectorOutput struct {
// Information about the detector (instance).
Detector *types.Detector
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDetectorMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeDetector{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeDetector{}, 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 = addOpDescribeDetectorValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDetector(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_opDescribeDetector(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ioteventsdata",
OperationName: "DescribeDetector",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ioteventsdata
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/ioteventsdata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists one or more alarms. The operation returns only the metadata associated
// with each alarm.
func (c *Client) ListAlarms(ctx context.Context, params *ListAlarmsInput, optFns ...func(*Options)) (*ListAlarmsOutput, error) {
if params == nil {
params = &ListAlarmsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListAlarms", params, optFns, c.addOperationListAlarmsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListAlarmsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListAlarmsInput struct {
// The name of the alarm model.
//
// This member is required.
AlarmModelName *string
// The maximum number of results to be returned per request.
MaxResults *int32
// The token that you can use to return the next set of results.
NextToken *string
noSmithyDocumentSerde
}
type ListAlarmsOutput struct {
// A list that summarizes each alarm.
AlarmSummaries []types.AlarmSummary
// The token that you can use to return the next set of results, or null if there
// are no more results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListAlarmsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListAlarms{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListAlarms{}, 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 = addOpListAlarmsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListAlarms(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_opListAlarms(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ioteventsdata",
OperationName: "ListAlarms",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ioteventsdata
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/ioteventsdata/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists detectors (the instances of a detector model).
func (c *Client) ListDetectors(ctx context.Context, params *ListDetectorsInput, optFns ...func(*Options)) (*ListDetectorsOutput, error) {
if params == nil {
params = &ListDetectorsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDetectors", params, optFns, c.addOperationListDetectorsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDetectorsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDetectorsInput struct {
// The name of the detector model whose detectors (instances) are listed.
//
// This member is required.
DetectorModelName *string
// The maximum number of results to be returned per request.
MaxResults *int32
// The token that you can use to return the next set of results.
NextToken *string
// A filter that limits results to those detectors (instances) in the given state.
StateName *string
noSmithyDocumentSerde
}
type ListDetectorsOutput struct {
// A list of summary information about the detectors (instances).
DetectorSummaries []types.DetectorSummary
// The token that you can use to return the next set of results, or null if there
// are no more results.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDetectorsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListDetectors{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListDetectors{}, 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 = addOpListDetectorsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListDetectors(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_opListDetectors(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ioteventsdata",
OperationName: "ListDetectors",
}
}
| 138 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ioteventsdata
import (
"bytes"
"context"
"encoding/json"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
"github.com/aws/aws-sdk-go-v2/service/ioteventsdata/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"
"strings"
)
type awsRestjson1_deserializeOpBatchAcknowledgeAlarm struct {
}
func (*awsRestjson1_deserializeOpBatchAcknowledgeAlarm) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpBatchAcknowledgeAlarm) 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_deserializeOpErrorBatchAcknowledgeAlarm(response, &metadata)
}
output := &BatchAcknowledgeAlarmOutput{}
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_deserializeOpDocumentBatchAcknowledgeAlarmOutput(&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_deserializeOpErrorBatchAcknowledgeAlarm(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentBatchAcknowledgeAlarmOutput(v **BatchAcknowledgeAlarmOutput, 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 *BatchAcknowledgeAlarmOutput
if *v == nil {
sv = &BatchAcknowledgeAlarmOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "errorEntries":
if err := awsRestjson1_deserializeDocumentBatchAlarmActionErrorEntries(&sv.ErrorEntries, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpBatchDeleteDetector struct {
}
func (*awsRestjson1_deserializeOpBatchDeleteDetector) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpBatchDeleteDetector) 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_deserializeOpErrorBatchDeleteDetector(response, &metadata)
}
output := &BatchDeleteDetectorOutput{}
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_deserializeOpDocumentBatchDeleteDetectorOutput(&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_deserializeOpErrorBatchDeleteDetector(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentBatchDeleteDetectorOutput(v **BatchDeleteDetectorOutput, 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 *BatchDeleteDetectorOutput
if *v == nil {
sv = &BatchDeleteDetectorOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "batchDeleteDetectorErrorEntries":
if err := awsRestjson1_deserializeDocumentBatchDeleteDetectorErrorEntries(&sv.BatchDeleteDetectorErrorEntries, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpBatchDisableAlarm struct {
}
func (*awsRestjson1_deserializeOpBatchDisableAlarm) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpBatchDisableAlarm) 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_deserializeOpErrorBatchDisableAlarm(response, &metadata)
}
output := &BatchDisableAlarmOutput{}
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_deserializeOpDocumentBatchDisableAlarmOutput(&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_deserializeOpErrorBatchDisableAlarm(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentBatchDisableAlarmOutput(v **BatchDisableAlarmOutput, 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 *BatchDisableAlarmOutput
if *v == nil {
sv = &BatchDisableAlarmOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "errorEntries":
if err := awsRestjson1_deserializeDocumentBatchAlarmActionErrorEntries(&sv.ErrorEntries, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpBatchEnableAlarm struct {
}
func (*awsRestjson1_deserializeOpBatchEnableAlarm) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpBatchEnableAlarm) 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_deserializeOpErrorBatchEnableAlarm(response, &metadata)
}
output := &BatchEnableAlarmOutput{}
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_deserializeOpDocumentBatchEnableAlarmOutput(&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_deserializeOpErrorBatchEnableAlarm(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentBatchEnableAlarmOutput(v **BatchEnableAlarmOutput, 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 *BatchEnableAlarmOutput
if *v == nil {
sv = &BatchEnableAlarmOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "errorEntries":
if err := awsRestjson1_deserializeDocumentBatchAlarmActionErrorEntries(&sv.ErrorEntries, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpBatchPutMessage struct {
}
func (*awsRestjson1_deserializeOpBatchPutMessage) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpBatchPutMessage) 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_deserializeOpErrorBatchPutMessage(response, &metadata)
}
output := &BatchPutMessageOutput{}
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_deserializeOpDocumentBatchPutMessageOutput(&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_deserializeOpErrorBatchPutMessage(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentBatchPutMessageOutput(v **BatchPutMessageOutput, 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 *BatchPutMessageOutput
if *v == nil {
sv = &BatchPutMessageOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "BatchPutMessageErrorEntries":
if err := awsRestjson1_deserializeDocumentBatchPutMessageErrorEntries(&sv.BatchPutMessageErrorEntries, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpBatchResetAlarm struct {
}
func (*awsRestjson1_deserializeOpBatchResetAlarm) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpBatchResetAlarm) 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_deserializeOpErrorBatchResetAlarm(response, &metadata)
}
output := &BatchResetAlarmOutput{}
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_deserializeOpDocumentBatchResetAlarmOutput(&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_deserializeOpErrorBatchResetAlarm(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentBatchResetAlarmOutput(v **BatchResetAlarmOutput, 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 *BatchResetAlarmOutput
if *v == nil {
sv = &BatchResetAlarmOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "errorEntries":
if err := awsRestjson1_deserializeDocumentBatchAlarmActionErrorEntries(&sv.ErrorEntries, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpBatchSnoozeAlarm struct {
}
func (*awsRestjson1_deserializeOpBatchSnoozeAlarm) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpBatchSnoozeAlarm) 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_deserializeOpErrorBatchSnoozeAlarm(response, &metadata)
}
output := &BatchSnoozeAlarmOutput{}
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_deserializeOpDocumentBatchSnoozeAlarmOutput(&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_deserializeOpErrorBatchSnoozeAlarm(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentBatchSnoozeAlarmOutput(v **BatchSnoozeAlarmOutput, 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 *BatchSnoozeAlarmOutput
if *v == nil {
sv = &BatchSnoozeAlarmOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "errorEntries":
if err := awsRestjson1_deserializeDocumentBatchAlarmActionErrorEntries(&sv.ErrorEntries, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpBatchUpdateDetector struct {
}
func (*awsRestjson1_deserializeOpBatchUpdateDetector) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpBatchUpdateDetector) 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_deserializeOpErrorBatchUpdateDetector(response, &metadata)
}
output := &BatchUpdateDetectorOutput{}
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_deserializeOpDocumentBatchUpdateDetectorOutput(&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_deserializeOpErrorBatchUpdateDetector(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentBatchUpdateDetectorOutput(v **BatchUpdateDetectorOutput, 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 *BatchUpdateDetectorOutput
if *v == nil {
sv = &BatchUpdateDetectorOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "batchUpdateDetectorErrorEntries":
if err := awsRestjson1_deserializeDocumentBatchUpdateDetectorErrorEntries(&sv.BatchUpdateDetectorErrorEntries, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDescribeAlarm struct {
}
func (*awsRestjson1_deserializeOpDescribeAlarm) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDescribeAlarm) 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_deserializeOpErrorDescribeAlarm(response, &metadata)
}
output := &DescribeAlarmOutput{}
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_deserializeOpDocumentDescribeAlarmOutput(&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_deserializeOpErrorDescribeAlarm(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDescribeAlarmOutput(v **DescribeAlarmOutput, 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 *DescribeAlarmOutput
if *v == nil {
sv = &DescribeAlarmOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "alarm":
if err := awsRestjson1_deserializeDocumentAlarm(&sv.Alarm, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDescribeDetector struct {
}
func (*awsRestjson1_deserializeOpDescribeDetector) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDescribeDetector) 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_deserializeOpErrorDescribeDetector(response, &metadata)
}
output := &DescribeDetectorOutput{}
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_deserializeOpDocumentDescribeDetectorOutput(&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_deserializeOpErrorDescribeDetector(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDescribeDetectorOutput(v **DescribeDetectorOutput, 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 *DescribeDetectorOutput
if *v == nil {
sv = &DescribeDetectorOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "detector":
if err := awsRestjson1_deserializeDocumentDetector(&sv.Detector, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListAlarms struct {
}
func (*awsRestjson1_deserializeOpListAlarms) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListAlarms) 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_deserializeOpErrorListAlarms(response, &metadata)
}
output := &ListAlarmsOutput{}
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_deserializeOpDocumentListAlarmsOutput(&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_deserializeOpErrorListAlarms(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListAlarmsOutput(v **ListAlarmsOutput, 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 *ListAlarmsOutput
if *v == nil {
sv = &ListAlarmsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "alarmSummaries":
if err := awsRestjson1_deserializeDocumentAlarmSummaries(&sv.AlarmSummaries, 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_deserializeOpListDetectors struct {
}
func (*awsRestjson1_deserializeOpListDetectors) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListDetectors) 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_deserializeOpErrorListDetectors(response, &metadata)
}
output := &ListDetectorsOutput{}
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_deserializeOpDocumentListDetectorsOutput(&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_deserializeOpErrorListDetectors(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("InternalFailureException", errorCode):
return awsRestjson1_deserializeErrorInternalFailureException(response, errorBody)
case strings.EqualFold("InvalidRequestException", errorCode):
return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ServiceUnavailableException", errorCode):
return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListDetectorsOutput(v **ListDetectorsOutput, 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 *ListDetectorsOutput
if *v == nil {
sv = &ListDetectorsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "detectorSummaries":
if err := awsRestjson1_deserializeDocumentDetectorSummaries(&sv.DetectorSummaries, 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
}
func awsRestjson1_deserializeErrorInternalFailureException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.InternalFailureException{}
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_deserializeDocumentInternalFailureException(&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_deserializeErrorInvalidRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.InvalidRequestException{}
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_deserializeDocumentInvalidRequestException(&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_deserializeErrorServiceUnavailableException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ServiceUnavailableException{}
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_deserializeDocumentServiceUnavailableException(&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_deserializeDocumentAcknowledgeActionConfiguration(v **types.AcknowledgeActionConfiguration, 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.AcknowledgeActionConfiguration
if *v == nil {
sv = &types.AcknowledgeActionConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "note":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Note to be of type string, got %T instead", value)
}
sv.Note = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAlarm(v **types.Alarm, 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.Alarm
if *v == nil {
sv = &types.Alarm{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "alarmModelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelName to be of type string, got %T instead", value)
}
sv.AlarmModelName = ptr.String(jtv)
}
case "alarmModelVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelVersion to be of type string, got %T instead", value)
}
sv.AlarmModelVersion = ptr.String(jtv)
}
case "alarmState":
if err := awsRestjson1_deserializeDocumentAlarmState(&sv.AlarmState, value); err != nil {
return err
}
case "creationTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "keyValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyValue to be of type string, got %T instead", value)
}
sv.KeyValue = ptr.String(jtv)
}
case "lastUpdateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "severity":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Severity to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Severity = ptr.Int32(int32(i64))
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAlarmState(v **types.AlarmState, 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.AlarmState
if *v == nil {
sv = &types.AlarmState{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "customerAction":
if err := awsRestjson1_deserializeDocumentCustomerAction(&sv.CustomerAction, value); err != nil {
return err
}
case "ruleEvaluation":
if err := awsRestjson1_deserializeDocumentRuleEvaluation(&sv.RuleEvaluation, value); err != nil {
return err
}
case "stateName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmStateName to be of type string, got %T instead", value)
}
sv.StateName = types.AlarmStateName(jtv)
}
case "systemEvent":
if err := awsRestjson1_deserializeDocumentSystemEvent(&sv.SystemEvent, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAlarmSummaries(v *[]types.AlarmSummary, 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.AlarmSummary
if *v == nil {
cv = []types.AlarmSummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.AlarmSummary
destAddr := &col
if err := awsRestjson1_deserializeDocumentAlarmSummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentAlarmSummary(v **types.AlarmSummary, 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.AlarmSummary
if *v == nil {
sv = &types.AlarmSummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "alarmModelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelName to be of type string, got %T instead", value)
}
sv.AlarmModelName = ptr.String(jtv)
}
case "alarmModelVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmModelVersion to be of type string, got %T instead", value)
}
sv.AlarmModelVersion = ptr.String(jtv)
}
case "creationTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "keyValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyValue to be of type string, got %T instead", value)
}
sv.KeyValue = ptr.String(jtv)
}
case "lastUpdateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "stateName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AlarmStateName to be of type string, got %T instead", value)
}
sv.StateName = types.AlarmStateName(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentBatchAlarmActionErrorEntries(v *[]types.BatchAlarmActionErrorEntry, 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.BatchAlarmActionErrorEntry
if *v == nil {
cv = []types.BatchAlarmActionErrorEntry{}
} else {
cv = *v
}
for _, value := range shape {
var col types.BatchAlarmActionErrorEntry
destAddr := &col
if err := awsRestjson1_deserializeDocumentBatchAlarmActionErrorEntry(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentBatchAlarmActionErrorEntry(v **types.BatchAlarmActionErrorEntry, 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.BatchAlarmActionErrorEntry
if *v == nil {
sv = &types.BatchAlarmActionErrorEntry{}
} 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 ErrorCode to be of type string, got %T instead", value)
}
sv.ErrorCode = types.ErrorCode(jtv)
}
case "errorMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
}
sv.ErrorMessage = ptr.String(jtv)
}
case "requestId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected RequestId to be of type string, got %T instead", value)
}
sv.RequestId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentBatchDeleteDetectorErrorEntries(v *[]types.BatchDeleteDetectorErrorEntry, 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.BatchDeleteDetectorErrorEntry
if *v == nil {
cv = []types.BatchDeleteDetectorErrorEntry{}
} else {
cv = *v
}
for _, value := range shape {
var col types.BatchDeleteDetectorErrorEntry
destAddr := &col
if err := awsRestjson1_deserializeDocumentBatchDeleteDetectorErrorEntry(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentBatchDeleteDetectorErrorEntry(v **types.BatchDeleteDetectorErrorEntry, 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.BatchDeleteDetectorErrorEntry
if *v == nil {
sv = &types.BatchDeleteDetectorErrorEntry{}
} 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 ErrorCode to be of type string, got %T instead", value)
}
sv.ErrorCode = types.ErrorCode(jtv)
}
case "errorMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
}
sv.ErrorMessage = ptr.String(jtv)
}
case "messageId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageId to be of type string, got %T instead", value)
}
sv.MessageId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentBatchPutMessageErrorEntries(v *[]types.BatchPutMessageErrorEntry, 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.BatchPutMessageErrorEntry
if *v == nil {
cv = []types.BatchPutMessageErrorEntry{}
} else {
cv = *v
}
for _, value := range shape {
var col types.BatchPutMessageErrorEntry
destAddr := &col
if err := awsRestjson1_deserializeDocumentBatchPutMessageErrorEntry(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentBatchPutMessageErrorEntry(v **types.BatchPutMessageErrorEntry, 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.BatchPutMessageErrorEntry
if *v == nil {
sv = &types.BatchPutMessageErrorEntry{}
} 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 ErrorCode to be of type string, got %T instead", value)
}
sv.ErrorCode = types.ErrorCode(jtv)
}
case "errorMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
}
sv.ErrorMessage = ptr.String(jtv)
}
case "messageId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageId to be of type string, got %T instead", value)
}
sv.MessageId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentBatchUpdateDetectorErrorEntries(v *[]types.BatchUpdateDetectorErrorEntry, 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.BatchUpdateDetectorErrorEntry
if *v == nil {
cv = []types.BatchUpdateDetectorErrorEntry{}
} else {
cv = *v
}
for _, value := range shape {
var col types.BatchUpdateDetectorErrorEntry
destAddr := &col
if err := awsRestjson1_deserializeDocumentBatchUpdateDetectorErrorEntry(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentBatchUpdateDetectorErrorEntry(v **types.BatchUpdateDetectorErrorEntry, 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.BatchUpdateDetectorErrorEntry
if *v == nil {
sv = &types.BatchUpdateDetectorErrorEntry{}
} 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 ErrorCode to be of type string, got %T instead", value)
}
sv.ErrorCode = types.ErrorCode(jtv)
}
case "errorMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
}
sv.ErrorMessage = ptr.String(jtv)
}
case "messageId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageId to be of type string, got %T instead", value)
}
sv.MessageId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentCustomerAction(v **types.CustomerAction, 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.CustomerAction
if *v == nil {
sv = &types.CustomerAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "acknowledgeActionConfiguration":
if err := awsRestjson1_deserializeDocumentAcknowledgeActionConfiguration(&sv.AcknowledgeActionConfiguration, value); err != nil {
return err
}
case "actionName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CustomerActionName to be of type string, got %T instead", value)
}
sv.ActionName = types.CustomerActionName(jtv)
}
case "disableActionConfiguration":
if err := awsRestjson1_deserializeDocumentDisableActionConfiguration(&sv.DisableActionConfiguration, value); err != nil {
return err
}
case "enableActionConfiguration":
if err := awsRestjson1_deserializeDocumentEnableActionConfiguration(&sv.EnableActionConfiguration, value); err != nil {
return err
}
case "resetActionConfiguration":
if err := awsRestjson1_deserializeDocumentResetActionConfiguration(&sv.ResetActionConfiguration, value); err != nil {
return err
}
case "snoozeActionConfiguration":
if err := awsRestjson1_deserializeDocumentSnoozeActionConfiguration(&sv.SnoozeActionConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDetector(v **types.Detector, 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.Detector
if *v == nil {
sv = &types.Detector{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "creationTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "detectorModelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DetectorModelName to be of type string, got %T instead", value)
}
sv.DetectorModelName = ptr.String(jtv)
}
case "detectorModelVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DetectorModelVersion to be of type string, got %T instead", value)
}
sv.DetectorModelVersion = ptr.String(jtv)
}
case "keyValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyValue to be of type string, got %T instead", value)
}
sv.KeyValue = ptr.String(jtv)
}
case "lastUpdateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "state":
if err := awsRestjson1_deserializeDocumentDetectorState(&sv.State, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDetectorState(v **types.DetectorState, 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.DetectorState
if *v == nil {
sv = &types.DetectorState{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "stateName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected StateName to be of type string, got %T instead", value)
}
sv.StateName = ptr.String(jtv)
}
case "timers":
if err := awsRestjson1_deserializeDocumentTimers(&sv.Timers, value); err != nil {
return err
}
case "variables":
if err := awsRestjson1_deserializeDocumentVariables(&sv.Variables, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDetectorStateSummary(v **types.DetectorStateSummary, 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.DetectorStateSummary
if *v == nil {
sv = &types.DetectorStateSummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "stateName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected StateName to be of type string, got %T instead", value)
}
sv.StateName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDetectorSummaries(v *[]types.DetectorSummary, 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.DetectorSummary
if *v == nil {
cv = []types.DetectorSummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.DetectorSummary
destAddr := &col
if err := awsRestjson1_deserializeDocumentDetectorSummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentDetectorSummary(v **types.DetectorSummary, 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.DetectorSummary
if *v == nil {
sv = &types.DetectorSummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "creationTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "detectorModelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DetectorModelName to be of type string, got %T instead", value)
}
sv.DetectorModelName = ptr.String(jtv)
}
case "detectorModelVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DetectorModelVersion to be of type string, got %T instead", value)
}
sv.DetectorModelVersion = ptr.String(jtv)
}
case "keyValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KeyValue to be of type string, got %T instead", value)
}
sv.KeyValue = ptr.String(jtv)
}
case "lastUpdateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "state":
if err := awsRestjson1_deserializeDocumentDetectorStateSummary(&sv.State, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDisableActionConfiguration(v **types.DisableActionConfiguration, 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.DisableActionConfiguration
if *v == nil {
sv = &types.DisableActionConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "note":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Note to be of type string, got %T instead", value)
}
sv.Note = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentEnableActionConfiguration(v **types.EnableActionConfiguration, 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.EnableActionConfiguration
if *v == nil {
sv = &types.EnableActionConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "note":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Note to be of type string, got %T instead", value)
}
sv.Note = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentInternalFailureException(v **types.InternalFailureException, 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.InternalFailureException
if *v == nil {
sv = &types.InternalFailureException{}
} 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
}
func awsRestjson1_deserializeDocumentInvalidRequestException(v **types.InvalidRequestException, 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.InvalidRequestException
if *v == nil {
sv = &types.InvalidRequestException{}
} 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
}
func awsRestjson1_deserializeDocumentResetActionConfiguration(v **types.ResetActionConfiguration, 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.ResetActionConfiguration
if *v == nil {
sv = &types.ResetActionConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "note":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Note to be of type string, got %T instead", value)
}
sv.Note = ptr.String(jtv)
}
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 ErrorMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentRuleEvaluation(v **types.RuleEvaluation, 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.RuleEvaluation
if *v == nil {
sv = &types.RuleEvaluation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "simpleRuleEvaluation":
if err := awsRestjson1_deserializeDocumentSimpleRuleEvaluation(&sv.SimpleRuleEvaluation, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentServiceUnavailableException(v **types.ServiceUnavailableException, 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.ServiceUnavailableException
if *v == nil {
sv = &types.ServiceUnavailableException{}
} 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
}
func awsRestjson1_deserializeDocumentSimpleRuleEvaluation(v **types.SimpleRuleEvaluation, 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.SimpleRuleEvaluation
if *v == nil {
sv = &types.SimpleRuleEvaluation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "inputPropertyValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected InputPropertyValue to be of type string, got %T instead", value)
}
sv.InputPropertyValue = ptr.String(jtv)
}
case "operator":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ComparisonOperator to be of type string, got %T instead", value)
}
sv.Operator = types.ComparisonOperator(jtv)
}
case "thresholdValue":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ThresholdValue to be of type string, got %T instead", value)
}
sv.ThresholdValue = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSnoozeActionConfiguration(v **types.SnoozeActionConfiguration, 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.SnoozeActionConfiguration
if *v == nil {
sv = &types.SnoozeActionConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "note":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Note to be of type string, got %T instead", value)
}
sv.Note = ptr.String(jtv)
}
case "snoozeDuration":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected SnoozeDuration to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.SnoozeDuration = ptr.Int32(int32(i64))
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentStateChangeConfiguration(v **types.StateChangeConfiguration, 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.StateChangeConfiguration
if *v == nil {
sv = &types.StateChangeConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "triggerType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TriggerType to be of type string, got %T instead", value)
}
sv.TriggerType = types.TriggerType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSystemEvent(v **types.SystemEvent, 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.SystemEvent
if *v == nil {
sv = &types.SystemEvent{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "eventType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EventType to be of type string, got %T instead", value)
}
sv.EventType = types.EventType(jtv)
}
case "stateChangeConfiguration":
if err := awsRestjson1_deserializeDocumentStateChangeConfiguration(&sv.StateChangeConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
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 ErrorMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTimer(v **types.Timer, 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.Timer
if *v == nil {
sv = &types.Timer{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TimerName to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "timestamp":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.Timestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTimers(v *[]types.Timer, 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.Timer
if *v == nil {
cv = []types.Timer{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Timer
destAddr := &col
if err := awsRestjson1_deserializeDocumentTimer(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentVariable(v **types.Variable, 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.Variable
if *v == nil {
sv = &types.Variable{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VariableName to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "value":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VariableValue to be of type string, got %T instead", value)
}
sv.Value = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentVariables(v *[]types.Variable, 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.Variable
if *v == nil {
cv = []types.Variable{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Variable
destAddr := &col
if err := awsRestjson1_deserializeDocumentVariable(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
| 3,911 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package ioteventsdata provides the API client, operations, and parameter types
// for AWS IoT Events Data.
//
// IoT Events monitors your equipment or device fleets for failures or changes in
// operation, and triggers actions when such events occur. You can use IoT Events
// Data API commands to send inputs to detectors, list detectors, and view or
// update a detector's status. For more information, see What is IoT Events? (https://docs.aws.amazon.com/iotevents/latest/developerguide/what-is-iotevents.html)
// in the IoT Events Developer Guide.
package ioteventsdata
| 12 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ioteventsdata
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/ioteventsdata/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 = "ioteventsdata"
}
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 ioteventsdata
// 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 ioteventsdata
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ioteventsdata
import (
"bytes"
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/ioteventsdata/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_serializeOpBatchAcknowledgeAlarm struct {
}
func (*awsRestjson1_serializeOpBatchAcknowledgeAlarm) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpBatchAcknowledgeAlarm) 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.(*BatchAcknowledgeAlarmInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/alarms/acknowledge")
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_serializeOpDocumentBatchAcknowledgeAlarmInput(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_serializeOpHttpBindingsBatchAcknowledgeAlarmInput(v *BatchAcknowledgeAlarmInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentBatchAcknowledgeAlarmInput(v *BatchAcknowledgeAlarmInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AcknowledgeActionRequests != nil {
ok := object.Key("acknowledgeActionRequests")
if err := awsRestjson1_serializeDocumentAcknowledgeAlarmActionRequests(v.AcknowledgeActionRequests, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpBatchDeleteDetector struct {
}
func (*awsRestjson1_serializeOpBatchDeleteDetector) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpBatchDeleteDetector) 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.(*BatchDeleteDetectorInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/detectors/delete")
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_serializeOpDocumentBatchDeleteDetectorInput(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_serializeOpHttpBindingsBatchDeleteDetectorInput(v *BatchDeleteDetectorInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentBatchDeleteDetectorInput(v *BatchDeleteDetectorInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Detectors != nil {
ok := object.Key("detectors")
if err := awsRestjson1_serializeDocumentDeleteDetectorRequests(v.Detectors, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpBatchDisableAlarm struct {
}
func (*awsRestjson1_serializeOpBatchDisableAlarm) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpBatchDisableAlarm) 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.(*BatchDisableAlarmInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/alarms/disable")
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_serializeOpDocumentBatchDisableAlarmInput(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_serializeOpHttpBindingsBatchDisableAlarmInput(v *BatchDisableAlarmInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentBatchDisableAlarmInput(v *BatchDisableAlarmInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DisableActionRequests != nil {
ok := object.Key("disableActionRequests")
if err := awsRestjson1_serializeDocumentDisableAlarmActionRequests(v.DisableActionRequests, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpBatchEnableAlarm struct {
}
func (*awsRestjson1_serializeOpBatchEnableAlarm) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpBatchEnableAlarm) 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.(*BatchEnableAlarmInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/alarms/enable")
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_serializeOpDocumentBatchEnableAlarmInput(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_serializeOpHttpBindingsBatchEnableAlarmInput(v *BatchEnableAlarmInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentBatchEnableAlarmInput(v *BatchEnableAlarmInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.EnableActionRequests != nil {
ok := object.Key("enableActionRequests")
if err := awsRestjson1_serializeDocumentEnableAlarmActionRequests(v.EnableActionRequests, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpBatchPutMessage struct {
}
func (*awsRestjson1_serializeOpBatchPutMessage) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpBatchPutMessage) 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.(*BatchPutMessageInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/inputs/messages")
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_serializeOpDocumentBatchPutMessageInput(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_serializeOpHttpBindingsBatchPutMessageInput(v *BatchPutMessageInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentBatchPutMessageInput(v *BatchPutMessageInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Messages != nil {
ok := object.Key("messages")
if err := awsRestjson1_serializeDocumentMessages(v.Messages, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpBatchResetAlarm struct {
}
func (*awsRestjson1_serializeOpBatchResetAlarm) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpBatchResetAlarm) 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.(*BatchResetAlarmInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/alarms/reset")
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_serializeOpDocumentBatchResetAlarmInput(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_serializeOpHttpBindingsBatchResetAlarmInput(v *BatchResetAlarmInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentBatchResetAlarmInput(v *BatchResetAlarmInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ResetActionRequests != nil {
ok := object.Key("resetActionRequests")
if err := awsRestjson1_serializeDocumentResetAlarmActionRequests(v.ResetActionRequests, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpBatchSnoozeAlarm struct {
}
func (*awsRestjson1_serializeOpBatchSnoozeAlarm) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpBatchSnoozeAlarm) 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.(*BatchSnoozeAlarmInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/alarms/snooze")
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_serializeOpDocumentBatchSnoozeAlarmInput(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_serializeOpHttpBindingsBatchSnoozeAlarmInput(v *BatchSnoozeAlarmInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentBatchSnoozeAlarmInput(v *BatchSnoozeAlarmInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.SnoozeActionRequests != nil {
ok := object.Key("snoozeActionRequests")
if err := awsRestjson1_serializeDocumentSnoozeAlarmActionRequests(v.SnoozeActionRequests, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpBatchUpdateDetector struct {
}
func (*awsRestjson1_serializeOpBatchUpdateDetector) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpBatchUpdateDetector) 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.(*BatchUpdateDetectorInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/detectors")
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_serializeOpDocumentBatchUpdateDetectorInput(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_serializeOpHttpBindingsBatchUpdateDetectorInput(v *BatchUpdateDetectorInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentBatchUpdateDetectorInput(v *BatchUpdateDetectorInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Detectors != nil {
ok := object.Key("detectors")
if err := awsRestjson1_serializeDocumentUpdateDetectorRequests(v.Detectors, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDescribeAlarm struct {
}
func (*awsRestjson1_serializeOpDescribeAlarm) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDescribeAlarm) 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.(*DescribeAlarmInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/alarms/{alarmModelName}/keyValues")
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_serializeOpHttpBindingsDescribeAlarmInput(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_serializeOpHttpBindingsDescribeAlarmInput(v *DescribeAlarmInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.AlarmModelName == nil || len(*v.AlarmModelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member alarmModelName must not be empty")}
}
if v.AlarmModelName != nil {
if err := encoder.SetURI("alarmModelName").String(*v.AlarmModelName); err != nil {
return err
}
}
if v.KeyValue != nil {
encoder.SetQuery("keyValue").String(*v.KeyValue)
}
return nil
}
type awsRestjson1_serializeOpDescribeDetector struct {
}
func (*awsRestjson1_serializeOpDescribeDetector) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDescribeDetector) 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.(*DescribeDetectorInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/detectors/{detectorModelName}/keyValues")
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_serializeOpHttpBindingsDescribeDetectorInput(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_serializeOpHttpBindingsDescribeDetectorInput(v *DescribeDetectorInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.DetectorModelName == nil || len(*v.DetectorModelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member detectorModelName must not be empty")}
}
if v.DetectorModelName != nil {
if err := encoder.SetURI("detectorModelName").String(*v.DetectorModelName); err != nil {
return err
}
}
if v.KeyValue != nil {
encoder.SetQuery("keyValue").String(*v.KeyValue)
}
return nil
}
type awsRestjson1_serializeOpListAlarms struct {
}
func (*awsRestjson1_serializeOpListAlarms) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListAlarms) 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.(*ListAlarmsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/alarms/{alarmModelName}")
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_serializeOpHttpBindingsListAlarmsInput(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_serializeOpHttpBindingsListAlarmsInput(v *ListAlarmsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.AlarmModelName == nil || len(*v.AlarmModelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member alarmModelName must not be empty")}
}
if v.AlarmModelName != nil {
if err := encoder.SetURI("alarmModelName").String(*v.AlarmModelName); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListDetectors struct {
}
func (*awsRestjson1_serializeOpListDetectors) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListDetectors) 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.(*ListDetectorsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/detectors/{detectorModelName}")
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_serializeOpHttpBindingsListDetectorsInput(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_serializeOpHttpBindingsListDetectorsInput(v *ListDetectorsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.DetectorModelName == nil || len(*v.DetectorModelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member detectorModelName must not be empty")}
}
if v.DetectorModelName != nil {
if err := encoder.SetURI("detectorModelName").String(*v.DetectorModelName); err != nil {
return err
}
}
if v.MaxResults != nil {
encoder.SetQuery("maxResults").Integer(*v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
if v.StateName != nil {
encoder.SetQuery("stateName").String(*v.StateName)
}
return nil
}
func awsRestjson1_serializeDocumentAcknowledgeAlarmActionRequest(v *types.AcknowledgeAlarmActionRequest, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AlarmModelName != nil {
ok := object.Key("alarmModelName")
ok.String(*v.AlarmModelName)
}
if v.KeyValue != nil {
ok := object.Key("keyValue")
ok.String(*v.KeyValue)
}
if v.Note != nil {
ok := object.Key("note")
ok.String(*v.Note)
}
if v.RequestId != nil {
ok := object.Key("requestId")
ok.String(*v.RequestId)
}
return nil
}
func awsRestjson1_serializeDocumentAcknowledgeAlarmActionRequests(v []types.AcknowledgeAlarmActionRequest, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentAcknowledgeAlarmActionRequest(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentDeleteDetectorRequest(v *types.DeleteDetectorRequest, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DetectorModelName != nil {
ok := object.Key("detectorModelName")
ok.String(*v.DetectorModelName)
}
if v.KeyValue != nil {
ok := object.Key("keyValue")
ok.String(*v.KeyValue)
}
if v.MessageId != nil {
ok := object.Key("messageId")
ok.String(*v.MessageId)
}
return nil
}
func awsRestjson1_serializeDocumentDeleteDetectorRequests(v []types.DeleteDetectorRequest, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentDeleteDetectorRequest(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentDetectorStateDefinition(v *types.DetectorStateDefinition, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.StateName != nil {
ok := object.Key("stateName")
ok.String(*v.StateName)
}
if v.Timers != nil {
ok := object.Key("timers")
if err := awsRestjson1_serializeDocumentTimerDefinitions(v.Timers, ok); err != nil {
return err
}
}
if v.Variables != nil {
ok := object.Key("variables")
if err := awsRestjson1_serializeDocumentVariableDefinitions(v.Variables, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentDisableAlarmActionRequest(v *types.DisableAlarmActionRequest, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AlarmModelName != nil {
ok := object.Key("alarmModelName")
ok.String(*v.AlarmModelName)
}
if v.KeyValue != nil {
ok := object.Key("keyValue")
ok.String(*v.KeyValue)
}
if v.Note != nil {
ok := object.Key("note")
ok.String(*v.Note)
}
if v.RequestId != nil {
ok := object.Key("requestId")
ok.String(*v.RequestId)
}
return nil
}
func awsRestjson1_serializeDocumentDisableAlarmActionRequests(v []types.DisableAlarmActionRequest, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentDisableAlarmActionRequest(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentEnableAlarmActionRequest(v *types.EnableAlarmActionRequest, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AlarmModelName != nil {
ok := object.Key("alarmModelName")
ok.String(*v.AlarmModelName)
}
if v.KeyValue != nil {
ok := object.Key("keyValue")
ok.String(*v.KeyValue)
}
if v.Note != nil {
ok := object.Key("note")
ok.String(*v.Note)
}
if v.RequestId != nil {
ok := object.Key("requestId")
ok.String(*v.RequestId)
}
return nil
}
func awsRestjson1_serializeDocumentEnableAlarmActionRequests(v []types.EnableAlarmActionRequest, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentEnableAlarmActionRequest(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentMessage(v *types.Message, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.InputName != nil {
ok := object.Key("inputName")
ok.String(*v.InputName)
}
if v.MessageId != nil {
ok := object.Key("messageId")
ok.String(*v.MessageId)
}
if v.Payload != nil {
ok := object.Key("payload")
ok.Base64EncodeBytes(v.Payload)
}
if v.Timestamp != nil {
ok := object.Key("timestamp")
if err := awsRestjson1_serializeDocumentTimestampValue(v.Timestamp, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentMessages(v []types.Message, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentMessage(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentResetAlarmActionRequest(v *types.ResetAlarmActionRequest, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AlarmModelName != nil {
ok := object.Key("alarmModelName")
ok.String(*v.AlarmModelName)
}
if v.KeyValue != nil {
ok := object.Key("keyValue")
ok.String(*v.KeyValue)
}
if v.Note != nil {
ok := object.Key("note")
ok.String(*v.Note)
}
if v.RequestId != nil {
ok := object.Key("requestId")
ok.String(*v.RequestId)
}
return nil
}
func awsRestjson1_serializeDocumentResetAlarmActionRequests(v []types.ResetAlarmActionRequest, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentResetAlarmActionRequest(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentSnoozeAlarmActionRequest(v *types.SnoozeAlarmActionRequest, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AlarmModelName != nil {
ok := object.Key("alarmModelName")
ok.String(*v.AlarmModelName)
}
if v.KeyValue != nil {
ok := object.Key("keyValue")
ok.String(*v.KeyValue)
}
if v.Note != nil {
ok := object.Key("note")
ok.String(*v.Note)
}
if v.RequestId != nil {
ok := object.Key("requestId")
ok.String(*v.RequestId)
}
if v.SnoozeDuration != nil {
ok := object.Key("snoozeDuration")
ok.Integer(*v.SnoozeDuration)
}
return nil
}
func awsRestjson1_serializeDocumentSnoozeAlarmActionRequests(v []types.SnoozeAlarmActionRequest, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentSnoozeAlarmActionRequest(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentTimerDefinition(v *types.TimerDefinition, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
if v.Seconds != nil {
ok := object.Key("seconds")
ok.Integer(*v.Seconds)
}
return nil
}
func awsRestjson1_serializeDocumentTimerDefinitions(v []types.TimerDefinition, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentTimerDefinition(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentTimestampValue(v *types.TimestampValue, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.TimeInMillis != nil {
ok := object.Key("timeInMillis")
ok.Long(*v.TimeInMillis)
}
return nil
}
func awsRestjson1_serializeDocumentUpdateDetectorRequest(v *types.UpdateDetectorRequest, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DetectorModelName != nil {
ok := object.Key("detectorModelName")
ok.String(*v.DetectorModelName)
}
if v.KeyValue != nil {
ok := object.Key("keyValue")
ok.String(*v.KeyValue)
}
if v.MessageId != nil {
ok := object.Key("messageId")
ok.String(*v.MessageId)
}
if v.State != nil {
ok := object.Key("state")
if err := awsRestjson1_serializeDocumentDetectorStateDefinition(v.State, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentUpdateDetectorRequests(v []types.UpdateDetectorRequest, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentUpdateDetectorRequest(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentVariableDefinition(v *types.VariableDefinition, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
if v.Value != nil {
ok := object.Key("value")
ok.String(*v.Value)
}
return nil
}
func awsRestjson1_serializeDocumentVariableDefinitions(v []types.VariableDefinition, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentVariableDefinition(&v[i], av); err != nil {
return err
}
}
return nil
}
| 1,258 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package ioteventsdata
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/ioteventsdata/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpBatchAcknowledgeAlarm struct {
}
func (*validateOpBatchAcknowledgeAlarm) ID() string {
return "OperationInputValidation"
}
func (m *validateOpBatchAcknowledgeAlarm) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*BatchAcknowledgeAlarmInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpBatchAcknowledgeAlarmInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpBatchDeleteDetector struct {
}
func (*validateOpBatchDeleteDetector) ID() string {
return "OperationInputValidation"
}
func (m *validateOpBatchDeleteDetector) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*BatchDeleteDetectorInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpBatchDeleteDetectorInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpBatchDisableAlarm struct {
}
func (*validateOpBatchDisableAlarm) ID() string {
return "OperationInputValidation"
}
func (m *validateOpBatchDisableAlarm) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*BatchDisableAlarmInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpBatchDisableAlarmInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpBatchEnableAlarm struct {
}
func (*validateOpBatchEnableAlarm) ID() string {
return "OperationInputValidation"
}
func (m *validateOpBatchEnableAlarm) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*BatchEnableAlarmInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpBatchEnableAlarmInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpBatchPutMessage struct {
}
func (*validateOpBatchPutMessage) ID() string {
return "OperationInputValidation"
}
func (m *validateOpBatchPutMessage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*BatchPutMessageInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpBatchPutMessageInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpBatchResetAlarm struct {
}
func (*validateOpBatchResetAlarm) ID() string {
return "OperationInputValidation"
}
func (m *validateOpBatchResetAlarm) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*BatchResetAlarmInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpBatchResetAlarmInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpBatchSnoozeAlarm struct {
}
func (*validateOpBatchSnoozeAlarm) ID() string {
return "OperationInputValidation"
}
func (m *validateOpBatchSnoozeAlarm) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*BatchSnoozeAlarmInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpBatchSnoozeAlarmInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpBatchUpdateDetector struct {
}
func (*validateOpBatchUpdateDetector) ID() string {
return "OperationInputValidation"
}
func (m *validateOpBatchUpdateDetector) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*BatchUpdateDetectorInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpBatchUpdateDetectorInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeAlarm struct {
}
func (*validateOpDescribeAlarm) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeAlarm) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeAlarmInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeAlarmInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeDetector struct {
}
func (*validateOpDescribeDetector) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeDetector) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeDetectorInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeDetectorInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListAlarms struct {
}
func (*validateOpListAlarms) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListAlarms) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListAlarmsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListAlarmsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListDetectors struct {
}
func (*validateOpListDetectors) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListDetectors) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListDetectorsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListDetectorsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpBatchAcknowledgeAlarmValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpBatchAcknowledgeAlarm{}, middleware.After)
}
func addOpBatchDeleteDetectorValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpBatchDeleteDetector{}, middleware.After)
}
func addOpBatchDisableAlarmValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpBatchDisableAlarm{}, middleware.After)
}
func addOpBatchEnableAlarmValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpBatchEnableAlarm{}, middleware.After)
}
func addOpBatchPutMessageValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpBatchPutMessage{}, middleware.After)
}
func addOpBatchResetAlarmValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpBatchResetAlarm{}, middleware.After)
}
func addOpBatchSnoozeAlarmValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpBatchSnoozeAlarm{}, middleware.After)
}
func addOpBatchUpdateDetectorValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpBatchUpdateDetector{}, middleware.After)
}
func addOpDescribeAlarmValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeAlarm{}, middleware.After)
}
func addOpDescribeDetectorValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeDetector{}, middleware.After)
}
func addOpListAlarmsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListAlarms{}, middleware.After)
}
func addOpListDetectorsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListDetectors{}, middleware.After)
}
func validateAcknowledgeAlarmActionRequest(v *types.AcknowledgeAlarmActionRequest) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AcknowledgeAlarmActionRequest"}
if v.RequestId == nil {
invalidParams.Add(smithy.NewErrParamRequired("RequestId"))
}
if v.AlarmModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("AlarmModelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAcknowledgeAlarmActionRequests(v []types.AcknowledgeAlarmActionRequest) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AcknowledgeAlarmActionRequests"}
for i := range v {
if err := validateAcknowledgeAlarmActionRequest(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDeleteDetectorRequest(v *types.DeleteDetectorRequest) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteDetectorRequest"}
if v.MessageId == nil {
invalidParams.Add(smithy.NewErrParamRequired("MessageId"))
}
if v.DetectorModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DetectorModelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDeleteDetectorRequests(v []types.DeleteDetectorRequest) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteDetectorRequests"}
for i := range v {
if err := validateDeleteDetectorRequest(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDetectorStateDefinition(v *types.DetectorStateDefinition) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DetectorStateDefinition"}
if v.StateName == nil {
invalidParams.Add(smithy.NewErrParamRequired("StateName"))
}
if v.Variables == nil {
invalidParams.Add(smithy.NewErrParamRequired("Variables"))
} else if v.Variables != nil {
if err := validateVariableDefinitions(v.Variables); err != nil {
invalidParams.AddNested("Variables", err.(smithy.InvalidParamsError))
}
}
if v.Timers == nil {
invalidParams.Add(smithy.NewErrParamRequired("Timers"))
} else if v.Timers != nil {
if err := validateTimerDefinitions(v.Timers); err != nil {
invalidParams.AddNested("Timers", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDisableAlarmActionRequest(v *types.DisableAlarmActionRequest) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DisableAlarmActionRequest"}
if v.RequestId == nil {
invalidParams.Add(smithy.NewErrParamRequired("RequestId"))
}
if v.AlarmModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("AlarmModelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDisableAlarmActionRequests(v []types.DisableAlarmActionRequest) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DisableAlarmActionRequests"}
for i := range v {
if err := validateDisableAlarmActionRequest(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateEnableAlarmActionRequest(v *types.EnableAlarmActionRequest) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "EnableAlarmActionRequest"}
if v.RequestId == nil {
invalidParams.Add(smithy.NewErrParamRequired("RequestId"))
}
if v.AlarmModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("AlarmModelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateEnableAlarmActionRequests(v []types.EnableAlarmActionRequest) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "EnableAlarmActionRequests"}
for i := range v {
if err := validateEnableAlarmActionRequest(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateMessage(v *types.Message) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Message"}
if v.MessageId == nil {
invalidParams.Add(smithy.NewErrParamRequired("MessageId"))
}
if v.InputName == nil {
invalidParams.Add(smithy.NewErrParamRequired("InputName"))
}
if v.Payload == nil {
invalidParams.Add(smithy.NewErrParamRequired("Payload"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateMessages(v []types.Message) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Messages"}
for i := range v {
if err := validateMessage(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateResetAlarmActionRequest(v *types.ResetAlarmActionRequest) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ResetAlarmActionRequest"}
if v.RequestId == nil {
invalidParams.Add(smithy.NewErrParamRequired("RequestId"))
}
if v.AlarmModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("AlarmModelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateResetAlarmActionRequests(v []types.ResetAlarmActionRequest) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ResetAlarmActionRequests"}
for i := range v {
if err := validateResetAlarmActionRequest(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSnoozeAlarmActionRequest(v *types.SnoozeAlarmActionRequest) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SnoozeAlarmActionRequest"}
if v.RequestId == nil {
invalidParams.Add(smithy.NewErrParamRequired("RequestId"))
}
if v.AlarmModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("AlarmModelName"))
}
if v.SnoozeDuration == nil {
invalidParams.Add(smithy.NewErrParamRequired("SnoozeDuration"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSnoozeAlarmActionRequests(v []types.SnoozeAlarmActionRequest) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SnoozeAlarmActionRequests"}
for i := range v {
if err := validateSnoozeAlarmActionRequest(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTimerDefinition(v *types.TimerDefinition) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TimerDefinition"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.Seconds == nil {
invalidParams.Add(smithy.NewErrParamRequired("Seconds"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTimerDefinitions(v []types.TimerDefinition) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TimerDefinitions"}
for i := range v {
if err := validateTimerDefinition(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateUpdateDetectorRequest(v *types.UpdateDetectorRequest) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateDetectorRequest"}
if v.MessageId == nil {
invalidParams.Add(smithy.NewErrParamRequired("MessageId"))
}
if v.DetectorModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DetectorModelName"))
}
if v.State == nil {
invalidParams.Add(smithy.NewErrParamRequired("State"))
} else if v.State != nil {
if err := validateDetectorStateDefinition(v.State); err != nil {
invalidParams.AddNested("State", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateUpdateDetectorRequests(v []types.UpdateDetectorRequest) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateDetectorRequests"}
for i := range v {
if err := validateUpdateDetectorRequest(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateVariableDefinition(v *types.VariableDefinition) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "VariableDefinition"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.Value == nil {
invalidParams.Add(smithy.NewErrParamRequired("Value"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateVariableDefinitions(v []types.VariableDefinition) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "VariableDefinitions"}
for i := range v {
if err := validateVariableDefinition(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpBatchAcknowledgeAlarmInput(v *BatchAcknowledgeAlarmInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchAcknowledgeAlarmInput"}
if v.AcknowledgeActionRequests == nil {
invalidParams.Add(smithy.NewErrParamRequired("AcknowledgeActionRequests"))
} else if v.AcknowledgeActionRequests != nil {
if err := validateAcknowledgeAlarmActionRequests(v.AcknowledgeActionRequests); err != nil {
invalidParams.AddNested("AcknowledgeActionRequests", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpBatchDeleteDetectorInput(v *BatchDeleteDetectorInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteDetectorInput"}
if v.Detectors == nil {
invalidParams.Add(smithy.NewErrParamRequired("Detectors"))
} else if v.Detectors != nil {
if err := validateDeleteDetectorRequests(v.Detectors); err != nil {
invalidParams.AddNested("Detectors", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpBatchDisableAlarmInput(v *BatchDisableAlarmInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchDisableAlarmInput"}
if v.DisableActionRequests == nil {
invalidParams.Add(smithy.NewErrParamRequired("DisableActionRequests"))
} else if v.DisableActionRequests != nil {
if err := validateDisableAlarmActionRequests(v.DisableActionRequests); err != nil {
invalidParams.AddNested("DisableActionRequests", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpBatchEnableAlarmInput(v *BatchEnableAlarmInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchEnableAlarmInput"}
if v.EnableActionRequests == nil {
invalidParams.Add(smithy.NewErrParamRequired("EnableActionRequests"))
} else if v.EnableActionRequests != nil {
if err := validateEnableAlarmActionRequests(v.EnableActionRequests); err != nil {
invalidParams.AddNested("EnableActionRequests", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpBatchPutMessageInput(v *BatchPutMessageInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchPutMessageInput"}
if v.Messages == nil {
invalidParams.Add(smithy.NewErrParamRequired("Messages"))
} else if v.Messages != nil {
if err := validateMessages(v.Messages); err != nil {
invalidParams.AddNested("Messages", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpBatchResetAlarmInput(v *BatchResetAlarmInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchResetAlarmInput"}
if v.ResetActionRequests == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResetActionRequests"))
} else if v.ResetActionRequests != nil {
if err := validateResetAlarmActionRequests(v.ResetActionRequests); err != nil {
invalidParams.AddNested("ResetActionRequests", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpBatchSnoozeAlarmInput(v *BatchSnoozeAlarmInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchSnoozeAlarmInput"}
if v.SnoozeActionRequests == nil {
invalidParams.Add(smithy.NewErrParamRequired("SnoozeActionRequests"))
} else if v.SnoozeActionRequests != nil {
if err := validateSnoozeAlarmActionRequests(v.SnoozeActionRequests); err != nil {
invalidParams.AddNested("SnoozeActionRequests", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpBatchUpdateDetectorInput(v *BatchUpdateDetectorInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchUpdateDetectorInput"}
if v.Detectors == nil {
invalidParams.Add(smithy.NewErrParamRequired("Detectors"))
} else if v.Detectors != nil {
if err := validateUpdateDetectorRequests(v.Detectors); err != nil {
invalidParams.AddNested("Detectors", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeAlarmInput(v *DescribeAlarmInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeAlarmInput"}
if v.AlarmModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("AlarmModelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeDetectorInput(v *DescribeDetectorInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeDetectorInput"}
if v.DetectorModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DetectorModelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListAlarmsInput(v *ListAlarmsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListAlarmsInput"}
if v.AlarmModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("AlarmModelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListDetectorsInput(v *ListDetectorsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListDetectorsInput"}
if v.DetectorModelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DetectorModelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 904 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.