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 mediatailor
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// The resource to untag.
func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error) {
if params == nil {
params = &UntagResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UntagResource", params, optFns, c.addOperationUntagResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UntagResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type UntagResourceInput struct {
// The Amazon Resource Name (ARN) of the resource to untag.
//
// This member is required.
ResourceArn *string
// The tag keys associated with 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: "mediatailor",
OperationName: "UntagResource",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mediatailor
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/mediatailor/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Updates a channel. For information about MediaTailor channels, see Working with
// channels (https://docs.aws.amazon.com/mediatailor/latest/ug/channel-assembly-channels.html)
// in the MediaTailor User Guide.
func (c *Client) UpdateChannel(ctx context.Context, params *UpdateChannelInput, optFns ...func(*Options)) (*UpdateChannelOutput, error) {
if params == nil {
params = &UpdateChannelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateChannel", params, optFns, c.addOperationUpdateChannelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateChannelOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateChannelInput struct {
// The name of the channel.
//
// This member is required.
ChannelName *string
// The channel's output properties.
//
// This member is required.
Outputs []types.RequestOutputItem
// The slate used to fill gaps between programs in the schedule. You must
// configure filler slate if your channel uses the LINEAR PlaybackMode .
// MediaTailor doesn't support filler slate for channels using the LOOP PlaybackMode
// .
FillerSlate *types.SlateSource
noSmithyDocumentSerde
}
type UpdateChannelOutput struct {
// The Amazon Resource Name (ARN) associated with the channel.
Arn *string
// The name of the channel.
ChannelName *string
// Returns the state whether the channel is running or not.
ChannelState types.ChannelState
// The timestamp of when the channel was created.
CreationTime *time.Time
// The slate used to fill gaps between programs in the schedule. You must
// configure filler slate if your channel uses the LINEAR PlaybackMode .
// MediaTailor doesn't support filler slate for channels using the LOOP PlaybackMode
// .
FillerSlate *types.SlateSource
// The timestamp that indicates when the channel was last modified.
LastModifiedTime *time.Time
// The channel's output properties.
Outputs []types.ResponseOutputItem
// The type of playback mode for this channel. LINEAR - Programs play back-to-back
// only once. LOOP - Programs play back-to-back in an endless loop. When the last
// program in the schedule plays, playback loops back to the first program in the
// schedule.
PlaybackMode *string
// The tags to assign to the channel. Tags are key-value pairs that you can
// associate with Amazon resources to help with organization, access control, and
// cost tracking. For more information, see Tagging AWS Elemental MediaTailor
// Resources (https://docs.aws.amazon.com/mediatailor/latest/ug/tagging.html) .
Tags map[string]string
// The tier associated with this Channel.
Tier *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateChannelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateChannel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateChannel{}, 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 = addOpUpdateChannelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateChannel(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_opUpdateChannel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mediatailor",
OperationName: "UpdateChannel",
}
}
| 175 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mediatailor
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/mediatailor/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Updates a live source's configuration.
func (c *Client) UpdateLiveSource(ctx context.Context, params *UpdateLiveSourceInput, optFns ...func(*Options)) (*UpdateLiveSourceOutput, error) {
if params == nil {
params = &UpdateLiveSourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateLiveSource", params, optFns, c.addOperationUpdateLiveSourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateLiveSourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateLiveSourceInput struct {
// A list of HTTP package configurations for the live source on this account.
//
// This member is required.
HttpPackageConfigurations []types.HttpPackageConfiguration
// The name of the live source.
//
// This member is required.
LiveSourceName *string
// The name of the source location associated with this Live Source.
//
// This member is required.
SourceLocationName *string
noSmithyDocumentSerde
}
type UpdateLiveSourceOutput struct {
// The Amazon Resource Name (ARN) associated with this live source.
Arn *string
// The timestamp that indicates when the live source was created.
CreationTime *time.Time
// A list of HTTP package configurations for the live source on this account.
HttpPackageConfigurations []types.HttpPackageConfiguration
// The timestamp that indicates when the live source was last modified.
LastModifiedTime *time.Time
// The name of the live source.
LiveSourceName *string
// The name of the source location associated with the live source.
SourceLocationName *string
// The tags to assign to the live source. Tags are key-value pairs that you can
// associate with Amazon resources to help with organization, access control, and
// cost tracking. For more information, see Tagging AWS Elemental MediaTailor
// Resources (https://docs.aws.amazon.com/mediatailor/latest/ug/tagging.html) .
Tags map[string]string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateLiveSourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateLiveSource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateLiveSource{}, 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 = addOpUpdateLiveSourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateLiveSource(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_opUpdateLiveSource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mediatailor",
OperationName: "UpdateLiveSource",
}
}
| 157 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mediatailor
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/mediatailor/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Updates a program within a channel.
func (c *Client) UpdateProgram(ctx context.Context, params *UpdateProgramInput, optFns ...func(*Options)) (*UpdateProgramOutput, error) {
if params == nil {
params = &UpdateProgramInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateProgram", params, optFns, c.addOperationUpdateProgramMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateProgramOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateProgramInput struct {
// The name of the channel for this Program.
//
// This member is required.
ChannelName *string
// The name of the Program.
//
// This member is required.
ProgramName *string
// The schedule configuration settings.
//
// This member is required.
ScheduleConfiguration *types.UpdateProgramScheduleConfiguration
// The ad break configuration settings.
AdBreaks []types.AdBreak
noSmithyDocumentSerde
}
type UpdateProgramOutput struct {
// The ad break configuration settings.
AdBreaks []types.AdBreak
// The ARN to assign to the program.
Arn *string
// The name to assign to the channel for this program.
ChannelName *string
// The clip range configuration settings.
ClipRange *types.ClipRange
// The time the program was created.
CreationTime *time.Time
// The duration of the live program in milliseconds.
DurationMillis int64
// The name of the LiveSource for this Program.
LiveSourceName *string
// The name to assign to this program.
ProgramName *string
// The scheduled start time for this Program.
ScheduledStartTime *time.Time
// The name to assign to the source location for this program.
SourceLocationName *string
// The name that's used to refer to a VOD source.
VodSourceName *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateProgramMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateProgram{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateProgram{}, 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 = addOpUpdateProgramValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateProgram(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_opUpdateProgram(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mediatailor",
OperationName: "UpdateProgram",
}
}
| 169 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mediatailor
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/mediatailor/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Updates a source location. A source location is a container for sources. For
// more information about source locations, see Working with source locations (https://docs.aws.amazon.com/mediatailor/latest/ug/channel-assembly-source-locations.html)
// in the MediaTailor User Guide.
func (c *Client) UpdateSourceLocation(ctx context.Context, params *UpdateSourceLocationInput, optFns ...func(*Options)) (*UpdateSourceLocationOutput, error) {
if params == nil {
params = &UpdateSourceLocationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateSourceLocation", params, optFns, c.addOperationUpdateSourceLocationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateSourceLocationOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateSourceLocationInput struct {
// The HTTP configuration for the source location.
//
// This member is required.
HttpConfiguration *types.HttpConfiguration
// The name of the source location.
//
// This member is required.
SourceLocationName *string
// Access configuration parameters. Configures the type of authentication used to
// access content from your source location.
AccessConfiguration *types.AccessConfiguration
// The optional configuration for the host server that serves segments.
DefaultSegmentDeliveryConfiguration *types.DefaultSegmentDeliveryConfiguration
// A list of the segment delivery configurations associated with this resource.
SegmentDeliveryConfigurations []types.SegmentDeliveryConfiguration
noSmithyDocumentSerde
}
type UpdateSourceLocationOutput struct {
// Access configuration parameters. Configures the type of authentication used to
// access content from your source location.
AccessConfiguration *types.AccessConfiguration
// The Amazon Resource Name (ARN) associated with the source location.
Arn *string
// The timestamp that indicates when the source location was created.
CreationTime *time.Time
// The optional configuration for the host server that serves segments.
DefaultSegmentDeliveryConfiguration *types.DefaultSegmentDeliveryConfiguration
// The HTTP configuration for the source location.
HttpConfiguration *types.HttpConfiguration
// The timestamp that indicates when the source location was last modified.
LastModifiedTime *time.Time
// The segment delivery configurations for the source location. For information
// about MediaTailor configurations, see Working with configurations in AWS
// Elemental MediaTailor (https://docs.aws.amazon.com/mediatailor/latest/ug/configurations.html)
// .
SegmentDeliveryConfigurations []types.SegmentDeliveryConfiguration
// The name of the source location.
SourceLocationName *string
// The tags to assign to the source location. Tags are key-value pairs that you
// can associate with Amazon resources to help with organization, access control,
// and cost tracking. For more information, see Tagging AWS Elemental MediaTailor
// Resources (https://docs.aws.amazon.com/mediatailor/latest/ug/tagging.html) .
Tags map[string]string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateSourceLocationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateSourceLocation{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateSourceLocation{}, 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 = addOpUpdateSourceLocationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateSourceLocation(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_opUpdateSourceLocation(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mediatailor",
OperationName: "UpdateSourceLocation",
}
}
| 174 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mediatailor
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/mediatailor/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Updates a VOD source's configuration.
func (c *Client) UpdateVodSource(ctx context.Context, params *UpdateVodSourceInput, optFns ...func(*Options)) (*UpdateVodSourceOutput, error) {
if params == nil {
params = &UpdateVodSourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateVodSource", params, optFns, c.addOperationUpdateVodSourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateVodSourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateVodSourceInput struct {
// A list of HTTP package configurations for the VOD source on this account.
//
// This member is required.
HttpPackageConfigurations []types.HttpPackageConfiguration
// The name of the source location associated with this VOD Source.
//
// This member is required.
SourceLocationName *string
// The name of the VOD source.
//
// This member is required.
VodSourceName *string
noSmithyDocumentSerde
}
type UpdateVodSourceOutput struct {
// The Amazon Resource Name (ARN) associated with the VOD source.
Arn *string
// The timestamp that indicates when the VOD source was created.
CreationTime *time.Time
// A list of HTTP package configurations for the VOD source on this account.
HttpPackageConfigurations []types.HttpPackageConfiguration
// The timestamp that indicates when the VOD source was last modified.
LastModifiedTime *time.Time
// The name of the source location associated with the VOD source.
SourceLocationName *string
// The tags to assign to the VOD source. Tags are key-value pairs that you can
// associate with Amazon resources to help with organization, access control, and
// cost tracking. For more information, see Tagging AWS Elemental MediaTailor
// Resources (https://docs.aws.amazon.com/mediatailor/latest/ug/tagging.html) .
Tags map[string]string
// The name of the VOD source.
VodSourceName *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateVodSourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateVodSource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateVodSource{}, 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 = addOpUpdateVodSourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateVodSource(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_opUpdateVodSource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mediatailor",
OperationName: "UpdateVodSource",
}
}
| 157 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mediatailor
import (
"bytes"
"context"
"encoding/json"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
"github.com/aws/aws-sdk-go-v2/service/mediatailor/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_deserializeOpConfigureLogsForChannel struct {
}
func (*awsRestjson1_deserializeOpConfigureLogsForChannel) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpConfigureLogsForChannel) 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_deserializeOpErrorConfigureLogsForChannel(response, &metadata)
}
output := &ConfigureLogsForChannelOutput{}
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_deserializeOpDocumentConfigureLogsForChannelOutput(&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_deserializeOpErrorConfigureLogsForChannel(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentConfigureLogsForChannelOutput(v **ConfigureLogsForChannelOutput, 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 *ConfigureLogsForChannelOutput
if *v == nil {
sv = &ConfigureLogsForChannelOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ChannelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.ChannelName = ptr.String(jtv)
}
case "LogTypes":
if err := awsRestjson1_deserializeDocumentLogTypes(&sv.LogTypes, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpConfigureLogsForPlaybackConfiguration struct {
}
func (*awsRestjson1_deserializeOpConfigureLogsForPlaybackConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpConfigureLogsForPlaybackConfiguration) 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_deserializeOpErrorConfigureLogsForPlaybackConfiguration(response, &metadata)
}
output := &ConfigureLogsForPlaybackConfigurationOutput{}
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_deserializeOpDocumentConfigureLogsForPlaybackConfigurationOutput(&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_deserializeOpErrorConfigureLogsForPlaybackConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentConfigureLogsForPlaybackConfigurationOutput(v **ConfigureLogsForPlaybackConfigurationOutput, 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 *ConfigureLogsForPlaybackConfigurationOutput
if *v == nil {
sv = &ConfigureLogsForPlaybackConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "PercentEnabled":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.PercentEnabled = int32(i64)
}
case "PlaybackConfigurationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.PlaybackConfigurationName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpCreateChannel struct {
}
func (*awsRestjson1_deserializeOpCreateChannel) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpCreateChannel) 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_deserializeOpErrorCreateChannel(response, &metadata)
}
output := &CreateChannelOutput{}
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_deserializeOpDocumentCreateChannelOutput(&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_deserializeOpErrorCreateChannel(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentCreateChannelOutput(v **CreateChannelOutput, 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 *CreateChannelOutput
if *v == nil {
sv = &CreateChannelOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "ChannelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.ChannelName = ptr.String(jtv)
}
case "ChannelState":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ChannelState to be of type string, got %T instead", value)
}
sv.ChannelState = types.ChannelState(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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "FillerSlate":
if err := awsRestjson1_deserializeDocumentSlateSource(&sv.FillerSlate, value); err != nil {
return err
}
case "LastModifiedTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "Outputs":
if err := awsRestjson1_deserializeDocumentResponseOutputs(&sv.Outputs, value); err != nil {
return err
}
case "PlaybackMode":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.PlaybackMode = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
case "Tier":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Tier = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpCreateLiveSource struct {
}
func (*awsRestjson1_deserializeOpCreateLiveSource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpCreateLiveSource) 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_deserializeOpErrorCreateLiveSource(response, &metadata)
}
output := &CreateLiveSourceOutput{}
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_deserializeOpDocumentCreateLiveSourceOutput(&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_deserializeOpErrorCreateLiveSource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentCreateLiveSourceOutput(v **CreateLiveSourceOutput, 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 *CreateLiveSourceOutput
if *v == nil {
sv = &CreateLiveSourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "HttpPackageConfigurations":
if err := awsRestjson1_deserializeDocumentHttpPackageConfigurations(&sv.HttpPackageConfigurations, value); err != nil {
return err
}
case "LastModifiedTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "LiveSourceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.LiveSourceName = ptr.String(jtv)
}
case "SourceLocationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceLocationName = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpCreatePrefetchSchedule struct {
}
func (*awsRestjson1_deserializeOpCreatePrefetchSchedule) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpCreatePrefetchSchedule) 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_deserializeOpErrorCreatePrefetchSchedule(response, &metadata)
}
output := &CreatePrefetchScheduleOutput{}
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_deserializeOpDocumentCreatePrefetchScheduleOutput(&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_deserializeOpErrorCreatePrefetchSchedule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentCreatePrefetchScheduleOutput(v **CreatePrefetchScheduleOutput, 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 *CreatePrefetchScheduleOutput
if *v == nil {
sv = &CreatePrefetchScheduleOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "Consumption":
if err := awsRestjson1_deserializeDocumentPrefetchConsumption(&sv.Consumption, value); err != nil {
return err
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "PlaybackConfigurationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.PlaybackConfigurationName = ptr.String(jtv)
}
case "Retrieval":
if err := awsRestjson1_deserializeDocumentPrefetchRetrieval(&sv.Retrieval, value); err != nil {
return err
}
case "StreamId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.StreamId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpCreateProgram struct {
}
func (*awsRestjson1_deserializeOpCreateProgram) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpCreateProgram) 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_deserializeOpErrorCreateProgram(response, &metadata)
}
output := &CreateProgramOutput{}
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_deserializeOpDocumentCreateProgramOutput(&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_deserializeOpErrorCreateProgram(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentCreateProgramOutput(v **CreateProgramOutput, 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 *CreateProgramOutput
if *v == nil {
sv = &CreateProgramOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AdBreaks":
if err := awsRestjson1_deserializeDocument__listOfAdBreak(&sv.AdBreaks, value); err != nil {
return err
}
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "ChannelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.ChannelName = ptr.String(jtv)
}
case "ClipRange":
if err := awsRestjson1_deserializeDocumentClipRange(&sv.ClipRange, 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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "DurationMillis":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __long to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.DurationMillis = i64
}
case "LiveSourceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.LiveSourceName = ptr.String(jtv)
}
case "ProgramName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.ProgramName = ptr.String(jtv)
}
case "ScheduledStartTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.ScheduledStartTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "SourceLocationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceLocationName = ptr.String(jtv)
}
case "VodSourceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.VodSourceName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpCreateSourceLocation struct {
}
func (*awsRestjson1_deserializeOpCreateSourceLocation) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpCreateSourceLocation) 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_deserializeOpErrorCreateSourceLocation(response, &metadata)
}
output := &CreateSourceLocationOutput{}
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_deserializeOpDocumentCreateSourceLocationOutput(&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_deserializeOpErrorCreateSourceLocation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentCreateSourceLocationOutput(v **CreateSourceLocationOutput, 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 *CreateSourceLocationOutput
if *v == nil {
sv = &CreateSourceLocationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AccessConfiguration":
if err := awsRestjson1_deserializeDocumentAccessConfiguration(&sv.AccessConfiguration, value); err != nil {
return err
}
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "DefaultSegmentDeliveryConfiguration":
if err := awsRestjson1_deserializeDocumentDefaultSegmentDeliveryConfiguration(&sv.DefaultSegmentDeliveryConfiguration, value); err != nil {
return err
}
case "HttpConfiguration":
if err := awsRestjson1_deserializeDocumentHttpConfiguration(&sv.HttpConfiguration, value); err != nil {
return err
}
case "LastModifiedTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "SegmentDeliveryConfigurations":
if err := awsRestjson1_deserializeDocument__listOfSegmentDeliveryConfiguration(&sv.SegmentDeliveryConfigurations, value); err != nil {
return err
}
case "SourceLocationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceLocationName = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpCreateVodSource struct {
}
func (*awsRestjson1_deserializeOpCreateVodSource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpCreateVodSource) 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_deserializeOpErrorCreateVodSource(response, &metadata)
}
output := &CreateVodSourceOutput{}
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_deserializeOpDocumentCreateVodSourceOutput(&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_deserializeOpErrorCreateVodSource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentCreateVodSourceOutput(v **CreateVodSourceOutput, 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 *CreateVodSourceOutput
if *v == nil {
sv = &CreateVodSourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "HttpPackageConfigurations":
if err := awsRestjson1_deserializeDocumentHttpPackageConfigurations(&sv.HttpPackageConfigurations, value); err != nil {
return err
}
case "LastModifiedTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "SourceLocationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceLocationName = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
case "VodSourceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.VodSourceName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDeleteChannel struct {
}
func (*awsRestjson1_deserializeOpDeleteChannel) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeleteChannel) 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_deserializeOpErrorDeleteChannel(response, &metadata)
}
output := &DeleteChannelOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDeleteChannel(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpDeleteChannelPolicy struct {
}
func (*awsRestjson1_deserializeOpDeleteChannelPolicy) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeleteChannelPolicy) 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_deserializeOpErrorDeleteChannelPolicy(response, &metadata)
}
output := &DeleteChannelPolicyOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDeleteChannelPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpDeleteLiveSource struct {
}
func (*awsRestjson1_deserializeOpDeleteLiveSource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeleteLiveSource) 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_deserializeOpErrorDeleteLiveSource(response, &metadata)
}
output := &DeleteLiveSourceOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDeleteLiveSource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpDeletePlaybackConfiguration struct {
}
func (*awsRestjson1_deserializeOpDeletePlaybackConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeletePlaybackConfiguration) 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_deserializeOpErrorDeletePlaybackConfiguration(response, &metadata)
}
output := &DeletePlaybackConfigurationOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDeletePlaybackConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpDeletePrefetchSchedule struct {
}
func (*awsRestjson1_deserializeOpDeletePrefetchSchedule) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeletePrefetchSchedule) 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_deserializeOpErrorDeletePrefetchSchedule(response, &metadata)
}
output := &DeletePrefetchScheduleOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDeletePrefetchSchedule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpDeleteProgram struct {
}
func (*awsRestjson1_deserializeOpDeleteProgram) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeleteProgram) 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_deserializeOpErrorDeleteProgram(response, &metadata)
}
output := &DeleteProgramOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDeleteProgram(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpDeleteSourceLocation struct {
}
func (*awsRestjson1_deserializeOpDeleteSourceLocation) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeleteSourceLocation) 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_deserializeOpErrorDeleteSourceLocation(response, &metadata)
}
output := &DeleteSourceLocationOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDeleteSourceLocation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpDeleteVodSource struct {
}
func (*awsRestjson1_deserializeOpDeleteVodSource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeleteVodSource) 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_deserializeOpErrorDeleteVodSource(response, &metadata)
}
output := &DeleteVodSourceOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorDeleteVodSource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpDescribeChannel struct {
}
func (*awsRestjson1_deserializeOpDescribeChannel) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDescribeChannel) 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_deserializeOpErrorDescribeChannel(response, &metadata)
}
output := &DescribeChannelOutput{}
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_deserializeOpDocumentDescribeChannelOutput(&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_deserializeOpErrorDescribeChannel(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDescribeChannelOutput(v **DescribeChannelOutput, 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 *DescribeChannelOutput
if *v == nil {
sv = &DescribeChannelOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "ChannelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.ChannelName = ptr.String(jtv)
}
case "ChannelState":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ChannelState to be of type string, got %T instead", value)
}
sv.ChannelState = types.ChannelState(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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "FillerSlate":
if err := awsRestjson1_deserializeDocumentSlateSource(&sv.FillerSlate, value); err != nil {
return err
}
case "LastModifiedTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "LogConfiguration":
if err := awsRestjson1_deserializeDocumentLogConfigurationForChannel(&sv.LogConfiguration, value); err != nil {
return err
}
case "Outputs":
if err := awsRestjson1_deserializeDocumentResponseOutputs(&sv.Outputs, value); err != nil {
return err
}
case "PlaybackMode":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.PlaybackMode = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
case "Tier":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Tier = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDescribeLiveSource struct {
}
func (*awsRestjson1_deserializeOpDescribeLiveSource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDescribeLiveSource) 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_deserializeOpErrorDescribeLiveSource(response, &metadata)
}
output := &DescribeLiveSourceOutput{}
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_deserializeOpDocumentDescribeLiveSourceOutput(&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_deserializeOpErrorDescribeLiveSource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDescribeLiveSourceOutput(v **DescribeLiveSourceOutput, 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 *DescribeLiveSourceOutput
if *v == nil {
sv = &DescribeLiveSourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "HttpPackageConfigurations":
if err := awsRestjson1_deserializeDocumentHttpPackageConfigurations(&sv.HttpPackageConfigurations, value); err != nil {
return err
}
case "LastModifiedTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "LiveSourceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.LiveSourceName = ptr.String(jtv)
}
case "SourceLocationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceLocationName = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDescribeProgram struct {
}
func (*awsRestjson1_deserializeOpDescribeProgram) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDescribeProgram) 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_deserializeOpErrorDescribeProgram(response, &metadata)
}
output := &DescribeProgramOutput{}
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_deserializeOpDocumentDescribeProgramOutput(&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_deserializeOpErrorDescribeProgram(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDescribeProgramOutput(v **DescribeProgramOutput, 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 *DescribeProgramOutput
if *v == nil {
sv = &DescribeProgramOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AdBreaks":
if err := awsRestjson1_deserializeDocument__listOfAdBreak(&sv.AdBreaks, value); err != nil {
return err
}
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "ChannelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.ChannelName = ptr.String(jtv)
}
case "ClipRange":
if err := awsRestjson1_deserializeDocumentClipRange(&sv.ClipRange, 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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "DurationMillis":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Long to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.DurationMillis = ptr.Int64(i64)
}
case "LiveSourceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.LiveSourceName = ptr.String(jtv)
}
case "ProgramName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.ProgramName = ptr.String(jtv)
}
case "ScheduledStartTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.ScheduledStartTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "SourceLocationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceLocationName = ptr.String(jtv)
}
case "VodSourceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.VodSourceName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDescribeSourceLocation struct {
}
func (*awsRestjson1_deserializeOpDescribeSourceLocation) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDescribeSourceLocation) 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_deserializeOpErrorDescribeSourceLocation(response, &metadata)
}
output := &DescribeSourceLocationOutput{}
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_deserializeOpDocumentDescribeSourceLocationOutput(&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_deserializeOpErrorDescribeSourceLocation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDescribeSourceLocationOutput(v **DescribeSourceLocationOutput, 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 *DescribeSourceLocationOutput
if *v == nil {
sv = &DescribeSourceLocationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AccessConfiguration":
if err := awsRestjson1_deserializeDocumentAccessConfiguration(&sv.AccessConfiguration, value); err != nil {
return err
}
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "DefaultSegmentDeliveryConfiguration":
if err := awsRestjson1_deserializeDocumentDefaultSegmentDeliveryConfiguration(&sv.DefaultSegmentDeliveryConfiguration, value); err != nil {
return err
}
case "HttpConfiguration":
if err := awsRestjson1_deserializeDocumentHttpConfiguration(&sv.HttpConfiguration, value); err != nil {
return err
}
case "LastModifiedTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "SegmentDeliveryConfigurations":
if err := awsRestjson1_deserializeDocument__listOfSegmentDeliveryConfiguration(&sv.SegmentDeliveryConfigurations, value); err != nil {
return err
}
case "SourceLocationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceLocationName = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDescribeVodSource struct {
}
func (*awsRestjson1_deserializeOpDescribeVodSource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDescribeVodSource) 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_deserializeOpErrorDescribeVodSource(response, &metadata)
}
output := &DescribeVodSourceOutput{}
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_deserializeOpDocumentDescribeVodSourceOutput(&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_deserializeOpErrorDescribeVodSource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDescribeVodSourceOutput(v **DescribeVodSourceOutput, 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 *DescribeVodSourceOutput
if *v == nil {
sv = &DescribeVodSourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "HttpPackageConfigurations":
if err := awsRestjson1_deserializeDocumentHttpPackageConfigurations(&sv.HttpPackageConfigurations, value); err != nil {
return err
}
case "LastModifiedTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "SourceLocationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceLocationName = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
case "VodSourceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.VodSourceName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetChannelPolicy struct {
}
func (*awsRestjson1_deserializeOpGetChannelPolicy) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetChannelPolicy) 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_deserializeOpErrorGetChannelPolicy(response, &metadata)
}
output := &GetChannelPolicyOutput{}
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_deserializeOpDocumentGetChannelPolicyOutput(&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_deserializeOpErrorGetChannelPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetChannelPolicyOutput(v **GetChannelPolicyOutput, 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 *GetChannelPolicyOutput
if *v == nil {
sv = &GetChannelPolicyOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Policy":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Policy = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetChannelSchedule struct {
}
func (*awsRestjson1_deserializeOpGetChannelSchedule) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetChannelSchedule) 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_deserializeOpErrorGetChannelSchedule(response, &metadata)
}
output := &GetChannelScheduleOutput{}
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_deserializeOpDocumentGetChannelScheduleOutput(&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_deserializeOpErrorGetChannelSchedule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetChannelScheduleOutput(v **GetChannelScheduleOutput, 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 *GetChannelScheduleOutput
if *v == nil {
sv = &GetChannelScheduleOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Items":
if err := awsRestjson1_deserializeDocument__listOfScheduleEntry(&sv.Items, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetPlaybackConfiguration struct {
}
func (*awsRestjson1_deserializeOpGetPlaybackConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetPlaybackConfiguration) 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_deserializeOpErrorGetPlaybackConfiguration(response, &metadata)
}
output := &GetPlaybackConfigurationOutput{}
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_deserializeOpDocumentGetPlaybackConfigurationOutput(&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_deserializeOpErrorGetPlaybackConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetPlaybackConfigurationOutput(v **GetPlaybackConfigurationOutput, 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 *GetPlaybackConfigurationOutput
if *v == nil {
sv = &GetPlaybackConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AdDecisionServerUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.AdDecisionServerUrl = ptr.String(jtv)
}
case "AvailSuppression":
if err := awsRestjson1_deserializeDocumentAvailSuppression(&sv.AvailSuppression, value); err != nil {
return err
}
case "Bumper":
if err := awsRestjson1_deserializeDocumentBumper(&sv.Bumper, value); err != nil {
return err
}
case "CdnConfiguration":
if err := awsRestjson1_deserializeDocumentCdnConfiguration(&sv.CdnConfiguration, value); err != nil {
return err
}
case "ConfigurationAliases":
if err := awsRestjson1_deserializeDocumentConfigurationAliasesResponse(&sv.ConfigurationAliases, value); err != nil {
return err
}
case "DashConfiguration":
if err := awsRestjson1_deserializeDocumentDashConfiguration(&sv.DashConfiguration, value); err != nil {
return err
}
case "HlsConfiguration":
if err := awsRestjson1_deserializeDocumentHlsConfiguration(&sv.HlsConfiguration, value); err != nil {
return err
}
case "LivePreRollConfiguration":
if err := awsRestjson1_deserializeDocumentLivePreRollConfiguration(&sv.LivePreRollConfiguration, value); err != nil {
return err
}
case "LogConfiguration":
if err := awsRestjson1_deserializeDocumentLogConfiguration(&sv.LogConfiguration, value); err != nil {
return err
}
case "ManifestProcessingRules":
if err := awsRestjson1_deserializeDocumentManifestProcessingRules(&sv.ManifestProcessingRules, value); err != nil {
return err
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "PersonalizationThresholdSeconds":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __integerMin1 to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.PersonalizationThresholdSeconds = int32(i64)
}
case "PlaybackConfigurationArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.PlaybackConfigurationArn = ptr.String(jtv)
}
case "PlaybackEndpointPrefix":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.PlaybackEndpointPrefix = ptr.String(jtv)
}
case "SessionInitializationEndpointPrefix":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SessionInitializationEndpointPrefix = ptr.String(jtv)
}
case "SlateAdUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SlateAdUrl = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
case "TranscodeProfileName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.TranscodeProfileName = ptr.String(jtv)
}
case "VideoContentSourceUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.VideoContentSourceUrl = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetPrefetchSchedule struct {
}
func (*awsRestjson1_deserializeOpGetPrefetchSchedule) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetPrefetchSchedule) 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_deserializeOpErrorGetPrefetchSchedule(response, &metadata)
}
output := &GetPrefetchScheduleOutput{}
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_deserializeOpDocumentGetPrefetchScheduleOutput(&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_deserializeOpErrorGetPrefetchSchedule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetPrefetchScheduleOutput(v **GetPrefetchScheduleOutput, 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 *GetPrefetchScheduleOutput
if *v == nil {
sv = &GetPrefetchScheduleOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "Consumption":
if err := awsRestjson1_deserializeDocumentPrefetchConsumption(&sv.Consumption, value); err != nil {
return err
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "PlaybackConfigurationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.PlaybackConfigurationName = ptr.String(jtv)
}
case "Retrieval":
if err := awsRestjson1_deserializeDocumentPrefetchRetrieval(&sv.Retrieval, value); err != nil {
return err
}
case "StreamId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.StreamId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListAlerts struct {
}
func (*awsRestjson1_deserializeOpListAlerts) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListAlerts) 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_deserializeOpErrorListAlerts(response, &metadata)
}
output := &ListAlertsOutput{}
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_deserializeOpDocumentListAlertsOutput(&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_deserializeOpErrorListAlerts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListAlertsOutput(v **ListAlertsOutput, 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 *ListAlertsOutput
if *v == nil {
sv = &ListAlertsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Items":
if err := awsRestjson1_deserializeDocument__listOfAlert(&sv.Items, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListChannels struct {
}
func (*awsRestjson1_deserializeOpListChannels) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListChannels) 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_deserializeOpErrorListChannels(response, &metadata)
}
output := &ListChannelsOutput{}
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_deserializeOpDocumentListChannelsOutput(&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_deserializeOpErrorListChannels(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListChannelsOutput(v **ListChannelsOutput, 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 *ListChannelsOutput
if *v == nil {
sv = &ListChannelsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Items":
if err := awsRestjson1_deserializeDocument__listOfChannel(&sv.Items, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListLiveSources struct {
}
func (*awsRestjson1_deserializeOpListLiveSources) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListLiveSources) 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_deserializeOpErrorListLiveSources(response, &metadata)
}
output := &ListLiveSourcesOutput{}
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_deserializeOpDocumentListLiveSourcesOutput(&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_deserializeOpErrorListLiveSources(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListLiveSourcesOutput(v **ListLiveSourcesOutput, 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 *ListLiveSourcesOutput
if *v == nil {
sv = &ListLiveSourcesOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Items":
if err := awsRestjson1_deserializeDocument__listOfLiveSource(&sv.Items, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListPlaybackConfigurations struct {
}
func (*awsRestjson1_deserializeOpListPlaybackConfigurations) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListPlaybackConfigurations) 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_deserializeOpErrorListPlaybackConfigurations(response, &metadata)
}
output := &ListPlaybackConfigurationsOutput{}
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_deserializeOpDocumentListPlaybackConfigurationsOutput(&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_deserializeOpErrorListPlaybackConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListPlaybackConfigurationsOutput(v **ListPlaybackConfigurationsOutput, 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 *ListPlaybackConfigurationsOutput
if *v == nil {
sv = &ListPlaybackConfigurationsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Items":
if err := awsRestjson1_deserializeDocument__listOfPlaybackConfiguration(&sv.Items, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListPrefetchSchedules struct {
}
func (*awsRestjson1_deserializeOpListPrefetchSchedules) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListPrefetchSchedules) 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_deserializeOpErrorListPrefetchSchedules(response, &metadata)
}
output := &ListPrefetchSchedulesOutput{}
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_deserializeOpDocumentListPrefetchSchedulesOutput(&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_deserializeOpErrorListPrefetchSchedules(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListPrefetchSchedulesOutput(v **ListPrefetchSchedulesOutput, 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 *ListPrefetchSchedulesOutput
if *v == nil {
sv = &ListPrefetchSchedulesOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Items":
if err := awsRestjson1_deserializeDocument__listOfPrefetchSchedule(&sv.Items, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListSourceLocations struct {
}
func (*awsRestjson1_deserializeOpListSourceLocations) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListSourceLocations) 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_deserializeOpErrorListSourceLocations(response, &metadata)
}
output := &ListSourceLocationsOutput{}
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_deserializeOpDocumentListSourceLocationsOutput(&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_deserializeOpErrorListSourceLocations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListSourceLocationsOutput(v **ListSourceLocationsOutput, 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 *ListSourceLocationsOutput
if *v == nil {
sv = &ListSourceLocationsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Items":
if err := awsRestjson1_deserializeDocument__listOfSourceLocation(&sv.Items, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string 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("BadRequestException", errorCode):
return awsRestjson1_deserializeErrorBadRequestException(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_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListVodSources struct {
}
func (*awsRestjson1_deserializeOpListVodSources) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListVodSources) 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_deserializeOpErrorListVodSources(response, &metadata)
}
output := &ListVodSourcesOutput{}
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_deserializeOpDocumentListVodSourcesOutput(&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_deserializeOpErrorListVodSources(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListVodSourcesOutput(v **ListVodSourcesOutput, 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 *ListVodSourcesOutput
if *v == nil {
sv = &ListVodSourcesOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Items":
if err := awsRestjson1_deserializeDocument__listOfVodSource(&sv.Items, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpPutChannelPolicy struct {
}
func (*awsRestjson1_deserializeOpPutChannelPolicy) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpPutChannelPolicy) 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_deserializeOpErrorPutChannelPolicy(response, &metadata)
}
output := &PutChannelPolicyOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorPutChannelPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpPutPlaybackConfiguration struct {
}
func (*awsRestjson1_deserializeOpPutPlaybackConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpPutPlaybackConfiguration) 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_deserializeOpErrorPutPlaybackConfiguration(response, &metadata)
}
output := &PutPlaybackConfigurationOutput{}
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_deserializeOpDocumentPutPlaybackConfigurationOutput(&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_deserializeOpErrorPutPlaybackConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentPutPlaybackConfigurationOutput(v **PutPlaybackConfigurationOutput, 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 *PutPlaybackConfigurationOutput
if *v == nil {
sv = &PutPlaybackConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AdDecisionServerUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.AdDecisionServerUrl = ptr.String(jtv)
}
case "AvailSuppression":
if err := awsRestjson1_deserializeDocumentAvailSuppression(&sv.AvailSuppression, value); err != nil {
return err
}
case "Bumper":
if err := awsRestjson1_deserializeDocumentBumper(&sv.Bumper, value); err != nil {
return err
}
case "CdnConfiguration":
if err := awsRestjson1_deserializeDocumentCdnConfiguration(&sv.CdnConfiguration, value); err != nil {
return err
}
case "ConfigurationAliases":
if err := awsRestjson1_deserializeDocumentConfigurationAliasesResponse(&sv.ConfigurationAliases, value); err != nil {
return err
}
case "DashConfiguration":
if err := awsRestjson1_deserializeDocumentDashConfiguration(&sv.DashConfiguration, value); err != nil {
return err
}
case "HlsConfiguration":
if err := awsRestjson1_deserializeDocumentHlsConfiguration(&sv.HlsConfiguration, value); err != nil {
return err
}
case "LivePreRollConfiguration":
if err := awsRestjson1_deserializeDocumentLivePreRollConfiguration(&sv.LivePreRollConfiguration, value); err != nil {
return err
}
case "LogConfiguration":
if err := awsRestjson1_deserializeDocumentLogConfiguration(&sv.LogConfiguration, value); err != nil {
return err
}
case "ManifestProcessingRules":
if err := awsRestjson1_deserializeDocumentManifestProcessingRules(&sv.ManifestProcessingRules, value); err != nil {
return err
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "PersonalizationThresholdSeconds":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __integerMin1 to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.PersonalizationThresholdSeconds = int32(i64)
}
case "PlaybackConfigurationArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.PlaybackConfigurationArn = ptr.String(jtv)
}
case "PlaybackEndpointPrefix":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.PlaybackEndpointPrefix = ptr.String(jtv)
}
case "SessionInitializationEndpointPrefix":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SessionInitializationEndpointPrefix = ptr.String(jtv)
}
case "SlateAdUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SlateAdUrl = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
case "TranscodeProfileName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.TranscodeProfileName = ptr.String(jtv)
}
case "VideoContentSourceUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.VideoContentSourceUrl = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpStartChannel struct {
}
func (*awsRestjson1_deserializeOpStartChannel) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpStartChannel) 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_deserializeOpErrorStartChannel(response, &metadata)
}
output := &StartChannelOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorStartChannel(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpStopChannel struct {
}
func (*awsRestjson1_deserializeOpStopChannel) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpStopChannel) 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_deserializeOpErrorStopChannel(response, &metadata)
}
output := &StopChannelOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorStopChannel(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
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
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_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("BadRequestException", errorCode):
return awsRestjson1_deserializeErrorBadRequestException(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
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_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("BadRequestException", errorCode):
return awsRestjson1_deserializeErrorBadRequestException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpUpdateChannel struct {
}
func (*awsRestjson1_deserializeOpUpdateChannel) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateChannel) 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_deserializeOpErrorUpdateChannel(response, &metadata)
}
output := &UpdateChannelOutput{}
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_deserializeOpDocumentUpdateChannelOutput(&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_deserializeOpErrorUpdateChannel(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentUpdateChannelOutput(v **UpdateChannelOutput, 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 *UpdateChannelOutput
if *v == nil {
sv = &UpdateChannelOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "ChannelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.ChannelName = ptr.String(jtv)
}
case "ChannelState":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ChannelState to be of type string, got %T instead", value)
}
sv.ChannelState = types.ChannelState(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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "FillerSlate":
if err := awsRestjson1_deserializeDocumentSlateSource(&sv.FillerSlate, value); err != nil {
return err
}
case "LastModifiedTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "Outputs":
if err := awsRestjson1_deserializeDocumentResponseOutputs(&sv.Outputs, value); err != nil {
return err
}
case "PlaybackMode":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.PlaybackMode = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
case "Tier":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Tier = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpUpdateLiveSource struct {
}
func (*awsRestjson1_deserializeOpUpdateLiveSource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateLiveSource) 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_deserializeOpErrorUpdateLiveSource(response, &metadata)
}
output := &UpdateLiveSourceOutput{}
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_deserializeOpDocumentUpdateLiveSourceOutput(&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_deserializeOpErrorUpdateLiveSource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentUpdateLiveSourceOutput(v **UpdateLiveSourceOutput, 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 *UpdateLiveSourceOutput
if *v == nil {
sv = &UpdateLiveSourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "HttpPackageConfigurations":
if err := awsRestjson1_deserializeDocumentHttpPackageConfigurations(&sv.HttpPackageConfigurations, value); err != nil {
return err
}
case "LastModifiedTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "LiveSourceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.LiveSourceName = ptr.String(jtv)
}
case "SourceLocationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceLocationName = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpUpdateProgram struct {
}
func (*awsRestjson1_deserializeOpUpdateProgram) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateProgram) 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_deserializeOpErrorUpdateProgram(response, &metadata)
}
output := &UpdateProgramOutput{}
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_deserializeOpDocumentUpdateProgramOutput(&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_deserializeOpErrorUpdateProgram(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentUpdateProgramOutput(v **UpdateProgramOutput, 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 *UpdateProgramOutput
if *v == nil {
sv = &UpdateProgramOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AdBreaks":
if err := awsRestjson1_deserializeDocument__listOfAdBreak(&sv.AdBreaks, value); err != nil {
return err
}
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "ChannelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.ChannelName = ptr.String(jtv)
}
case "ClipRange":
if err := awsRestjson1_deserializeDocumentClipRange(&sv.ClipRange, 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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "DurationMillis":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __long to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.DurationMillis = i64
}
case "LiveSourceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.LiveSourceName = ptr.String(jtv)
}
case "ProgramName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.ProgramName = ptr.String(jtv)
}
case "ScheduledStartTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.ScheduledStartTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "SourceLocationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceLocationName = ptr.String(jtv)
}
case "VodSourceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.VodSourceName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpUpdateSourceLocation struct {
}
func (*awsRestjson1_deserializeOpUpdateSourceLocation) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateSourceLocation) 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_deserializeOpErrorUpdateSourceLocation(response, &metadata)
}
output := &UpdateSourceLocationOutput{}
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_deserializeOpDocumentUpdateSourceLocationOutput(&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_deserializeOpErrorUpdateSourceLocation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentUpdateSourceLocationOutput(v **UpdateSourceLocationOutput, 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 *UpdateSourceLocationOutput
if *v == nil {
sv = &UpdateSourceLocationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AccessConfiguration":
if err := awsRestjson1_deserializeDocumentAccessConfiguration(&sv.AccessConfiguration, value); err != nil {
return err
}
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "DefaultSegmentDeliveryConfiguration":
if err := awsRestjson1_deserializeDocumentDefaultSegmentDeliveryConfiguration(&sv.DefaultSegmentDeliveryConfiguration, value); err != nil {
return err
}
case "HttpConfiguration":
if err := awsRestjson1_deserializeDocumentHttpConfiguration(&sv.HttpConfiguration, value); err != nil {
return err
}
case "LastModifiedTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "SegmentDeliveryConfigurations":
if err := awsRestjson1_deserializeDocument__listOfSegmentDeliveryConfiguration(&sv.SegmentDeliveryConfigurations, value); err != nil {
return err
}
case "SourceLocationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceLocationName = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpUpdateVodSource struct {
}
func (*awsRestjson1_deserializeOpUpdateVodSource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateVodSource) 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_deserializeOpErrorUpdateVodSource(response, &metadata)
}
output := &UpdateVodSourceOutput{}
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_deserializeOpDocumentUpdateVodSourceOutput(&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_deserializeOpErrorUpdateVodSource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentUpdateVodSourceOutput(v **UpdateVodSourceOutput, 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 *UpdateVodSourceOutput
if *v == nil {
sv = &UpdateVodSourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "HttpPackageConfigurations":
if err := awsRestjson1_deserializeDocumentHttpPackageConfigurations(&sv.HttpPackageConfigurations, value); err != nil {
return err
}
case "LastModifiedTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "SourceLocationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceLocationName = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
case "VodSourceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.VodSourceName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeErrorBadRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.BadRequestException{}
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_deserializeDocumentBadRequestException(&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_deserializeDocument__listOf__string(v *[]string, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []string
if *v == nil {
cv = []string{}
} else {
cv = *v
}
for _, value := range shape {
var col string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocument__listOfAdBreak(v *[]types.AdBreak, 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.AdBreak
if *v == nil {
cv = []types.AdBreak{}
} else {
cv = *v
}
for _, value := range shape {
var col types.AdBreak
destAddr := &col
if err := awsRestjson1_deserializeDocumentAdBreak(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocument__listOfAlert(v *[]types.Alert, 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.Alert
if *v == nil {
cv = []types.Alert{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Alert
destAddr := &col
if err := awsRestjson1_deserializeDocumentAlert(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocument__listOfAvailMatchingCriteria(v *[]types.AvailMatchingCriteria, 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.AvailMatchingCriteria
if *v == nil {
cv = []types.AvailMatchingCriteria{}
} else {
cv = *v
}
for _, value := range shape {
var col types.AvailMatchingCriteria
destAddr := &col
if err := awsRestjson1_deserializeDocumentAvailMatchingCriteria(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocument__listOfChannel(v *[]types.Channel, 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.Channel
if *v == nil {
cv = []types.Channel{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Channel
destAddr := &col
if err := awsRestjson1_deserializeDocumentChannel(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocument__listOfLiveSource(v *[]types.LiveSource, 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.LiveSource
if *v == nil {
cv = []types.LiveSource{}
} else {
cv = *v
}
for _, value := range shape {
var col types.LiveSource
destAddr := &col
if err := awsRestjson1_deserializeDocumentLiveSource(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocument__listOfPlaybackConfiguration(v *[]types.PlaybackConfiguration, 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.PlaybackConfiguration
if *v == nil {
cv = []types.PlaybackConfiguration{}
} else {
cv = *v
}
for _, value := range shape {
var col types.PlaybackConfiguration
destAddr := &col
if err := awsRestjson1_deserializeDocumentPlaybackConfiguration(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocument__listOfPrefetchSchedule(v *[]types.PrefetchSchedule, 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.PrefetchSchedule
if *v == nil {
cv = []types.PrefetchSchedule{}
} else {
cv = *v
}
for _, value := range shape {
var col types.PrefetchSchedule
destAddr := &col
if err := awsRestjson1_deserializeDocumentPrefetchSchedule(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocument__listOfScheduleAdBreak(v *[]types.ScheduleAdBreak, 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.ScheduleAdBreak
if *v == nil {
cv = []types.ScheduleAdBreak{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ScheduleAdBreak
destAddr := &col
if err := awsRestjson1_deserializeDocumentScheduleAdBreak(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocument__listOfScheduleEntry(v *[]types.ScheduleEntry, 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.ScheduleEntry
if *v == nil {
cv = []types.ScheduleEntry{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ScheduleEntry
destAddr := &col
if err := awsRestjson1_deserializeDocumentScheduleEntry(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocument__listOfSegmentDeliveryConfiguration(v *[]types.SegmentDeliveryConfiguration, 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.SegmentDeliveryConfiguration
if *v == nil {
cv = []types.SegmentDeliveryConfiguration{}
} else {
cv = *v
}
for _, value := range shape {
var col types.SegmentDeliveryConfiguration
destAddr := &col
if err := awsRestjson1_deserializeDocumentSegmentDeliveryConfiguration(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocument__listOfSourceLocation(v *[]types.SourceLocation, 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.SourceLocation
if *v == nil {
cv = []types.SourceLocation{}
} else {
cv = *v
}
for _, value := range shape {
var col types.SourceLocation
destAddr := &col
if err := awsRestjson1_deserializeDocumentSourceLocation(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocument__listOfVodSource(v *[]types.VodSource, 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.VodSource
if *v == nil {
cv = []types.VodSource{}
} else {
cv = *v
}
for _, value := range shape {
var col types.VodSource
destAddr := &col
if err := awsRestjson1_deserializeDocumentVodSource(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocument__mapOf__string(v *map[string]string, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var mv map[string]string
if *v == nil {
mv = map[string]string{}
} else {
mv = *v
}
for key, value := range shape {
var parsedVal string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
parsedVal = jtv
}
mv[key] = parsedVal
}
*v = mv
return nil
}
func awsRestjson1_deserializeDocumentAccessConfiguration(v **types.AccessConfiguration, 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.AccessConfiguration
if *v == nil {
sv = &types.AccessConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AccessType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccessType to be of type string, got %T instead", value)
}
sv.AccessType = types.AccessType(jtv)
}
case "SecretsManagerAccessTokenConfiguration":
if err := awsRestjson1_deserializeDocumentSecretsManagerAccessTokenConfiguration(&sv.SecretsManagerAccessTokenConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAdBreak(v **types.AdBreak, 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.AdBreak
if *v == nil {
sv = &types.AdBreak{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "MessageType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MessageType to be of type string, got %T instead", value)
}
sv.MessageType = types.MessageType(jtv)
}
case "OffsetMillis":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __long to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.OffsetMillis = i64
}
case "Slate":
if err := awsRestjson1_deserializeDocumentSlateSource(&sv.Slate, value); err != nil {
return err
}
case "SpliceInsertMessage":
if err := awsRestjson1_deserializeDocumentSpliceInsertMessage(&sv.SpliceInsertMessage, value); err != nil {
return err
}
case "TimeSignalMessage":
if err := awsRestjson1_deserializeDocumentTimeSignalMessage(&sv.TimeSignalMessage, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAdMarkerPassthrough(v **types.AdMarkerPassthrough, 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.AdMarkerPassthrough
if *v == nil {
sv = &types.AdMarkerPassthrough{}
} 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 __boolean to be of type *bool, got %T instead", value)
}
sv.Enabled = jtv
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAlert(v **types.Alert, 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.Alert
if *v == nil {
sv = &types.Alert{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AlertCode":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.AlertCode = ptr.String(jtv)
}
case "AlertMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.AlertMessage = ptr.String(jtv)
}
case "LastModifiedTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "RelatedResourceArns":
if err := awsRestjson1_deserializeDocument__listOf__string(&sv.RelatedResourceArns, value); err != nil {
return err
}
case "ResourceArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.ResourceArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAvailMatchingCriteria(v **types.AvailMatchingCriteria, 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.AvailMatchingCriteria
if *v == nil {
sv = &types.AvailMatchingCriteria{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "DynamicVariable":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.DynamicVariable = ptr.String(jtv)
}
case "Operator":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Operator to be of type string, got %T instead", value)
}
sv.Operator = types.Operator(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAvailSuppression(v **types.AvailSuppression, 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.AvailSuppression
if *v == nil {
sv = &types.AvailSuppression{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "FillPolicy":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FillPolicy to be of type string, got %T instead", value)
}
sv.FillPolicy = types.FillPolicy(jtv)
}
case "Mode":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Mode to be of type string, got %T instead", value)
}
sv.Mode = types.Mode(jtv)
}
case "Value":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Value = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentBadRequestException(v **types.BadRequestException, 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.BadRequestException
if *v == nil {
sv = &types.BadRequestException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentBumper(v **types.Bumper, 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.Bumper
if *v == nil {
sv = &types.Bumper{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "EndUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.EndUrl = ptr.String(jtv)
}
case "StartUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.StartUrl = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentCdnConfiguration(v **types.CdnConfiguration, 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.CdnConfiguration
if *v == nil {
sv = &types.CdnConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AdSegmentUrlPrefix":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.AdSegmentUrlPrefix = ptr.String(jtv)
}
case "ContentSegmentUrlPrefix":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.ContentSegmentUrlPrefix = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentChannel(v **types.Channel, 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.Channel
if *v == nil {
sv = &types.Channel{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "ChannelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.ChannelName = ptr.String(jtv)
}
case "ChannelState":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.ChannelState = 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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "FillerSlate":
if err := awsRestjson1_deserializeDocumentSlateSource(&sv.FillerSlate, value); err != nil {
return err
}
case "LastModifiedTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "LogConfiguration":
if err := awsRestjson1_deserializeDocumentLogConfigurationForChannel(&sv.LogConfiguration, value); err != nil {
return err
}
case "Outputs":
if err := awsRestjson1_deserializeDocumentResponseOutputs(&sv.Outputs, value); err != nil {
return err
}
case "PlaybackMode":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.PlaybackMode = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
case "Tier":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Tier = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentClipRange(v **types.ClipRange, 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.ClipRange
if *v == nil {
sv = &types.ClipRange{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "EndOffsetMillis":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __long to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.EndOffsetMillis = i64
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentConfigurationAliasesResponse(v *map[string]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]map[string]string
if *v == nil {
mv = map[string]map[string]string{}
} else {
mv = *v
}
for key, value := range shape {
var parsedVal map[string]string
mapVar := parsedVal
if err := awsRestjson1_deserializeDocument__mapOf__string(&mapVar, value); err != nil {
return err
}
parsedVal = mapVar
mv[key] = parsedVal
}
*v = mv
return nil
}
func awsRestjson1_deserializeDocumentDashConfiguration(v **types.DashConfiguration, 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.DashConfiguration
if *v == nil {
sv = &types.DashConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ManifestEndpointPrefix":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.ManifestEndpointPrefix = ptr.String(jtv)
}
case "MpdLocation":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.MpdLocation = ptr.String(jtv)
}
case "OriginManifestType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected OriginManifestType to be of type string, got %T instead", value)
}
sv.OriginManifestType = types.OriginManifestType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDashPlaylistSettings(v **types.DashPlaylistSettings, 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.DashPlaylistSettings
if *v == nil {
sv = &types.DashPlaylistSettings{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ManifestWindowSeconds":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.ManifestWindowSeconds = int32(i64)
}
case "MinBufferTimeSeconds":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.MinBufferTimeSeconds = int32(i64)
}
case "MinUpdatePeriodSeconds":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.MinUpdatePeriodSeconds = int32(i64)
}
case "SuggestedPresentationDelaySeconds":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.SuggestedPresentationDelaySeconds = int32(i64)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDefaultSegmentDeliveryConfiguration(v **types.DefaultSegmentDeliveryConfiguration, 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.DefaultSegmentDeliveryConfiguration
if *v == nil {
sv = &types.DefaultSegmentDeliveryConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "BaseUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.BaseUrl = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentHlsConfiguration(v **types.HlsConfiguration, 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.HlsConfiguration
if *v == nil {
sv = &types.HlsConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ManifestEndpointPrefix":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.ManifestEndpointPrefix = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentHlsPlaylistSettings(v **types.HlsPlaylistSettings, 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.HlsPlaylistSettings
if *v == nil {
sv = &types.HlsPlaylistSettings{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ManifestWindowSeconds":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.ManifestWindowSeconds = int32(i64)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentHttpConfiguration(v **types.HttpConfiguration, 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.HttpConfiguration
if *v == nil {
sv = &types.HttpConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "BaseUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.BaseUrl = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentHttpPackageConfiguration(v **types.HttpPackageConfiguration, 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.HttpPackageConfiguration
if *v == nil {
sv = &types.HttpPackageConfiguration{}
} 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 __string to be of type string, got %T instead", value)
}
sv.Path = ptr.String(jtv)
}
case "SourceGroup":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceGroup = ptr.String(jtv)
}
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Type to be of type string, got %T instead", value)
}
sv.Type = types.Type(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentHttpPackageConfigurations(v *[]types.HttpPackageConfiguration, 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.HttpPackageConfiguration
if *v == nil {
cv = []types.HttpPackageConfiguration{}
} else {
cv = *v
}
for _, value := range shape {
var col types.HttpPackageConfiguration
destAddr := &col
if err := awsRestjson1_deserializeDocumentHttpPackageConfiguration(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentLivePreRollConfiguration(v **types.LivePreRollConfiguration, 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.LivePreRollConfiguration
if *v == nil {
sv = &types.LivePreRollConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AdDecisionServerUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.AdDecisionServerUrl = ptr.String(jtv)
}
case "MaxDurationSeconds":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.MaxDurationSeconds = int32(i64)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentLiveSource(v **types.LiveSource, 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.LiveSource
if *v == nil {
sv = &types.LiveSource{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "HttpPackageConfigurations":
if err := awsRestjson1_deserializeDocumentHttpPackageConfigurations(&sv.HttpPackageConfigurations, value); err != nil {
return err
}
case "LastModifiedTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "LiveSourceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.LiveSourceName = ptr.String(jtv)
}
case "SourceLocationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceLocationName = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentLogConfiguration(v **types.LogConfiguration, 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.LogConfiguration
if *v == nil {
sv = &types.LogConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "PercentEnabled":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.PercentEnabled = int32(i64)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentLogConfigurationForChannel(v **types.LogConfigurationForChannel, 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.LogConfigurationForChannel
if *v == nil {
sv = &types.LogConfigurationForChannel{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "LogTypes":
if err := awsRestjson1_deserializeDocumentLogTypes(&sv.LogTypes, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentLogTypes(v *[]types.LogType, 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.LogType
if *v == nil {
cv = []types.LogType{}
} else {
cv = *v
}
for _, value := range shape {
var col types.LogType
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LogType to be of type string, got %T instead", value)
}
col = types.LogType(jtv)
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentManifestProcessingRules(v **types.ManifestProcessingRules, 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.ManifestProcessingRules
if *v == nil {
sv = &types.ManifestProcessingRules{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AdMarkerPassthrough":
if err := awsRestjson1_deserializeDocumentAdMarkerPassthrough(&sv.AdMarkerPassthrough, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPlaybackConfiguration(v **types.PlaybackConfiguration, 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.PlaybackConfiguration
if *v == nil {
sv = &types.PlaybackConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AdDecisionServerUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.AdDecisionServerUrl = ptr.String(jtv)
}
case "AvailSuppression":
if err := awsRestjson1_deserializeDocumentAvailSuppression(&sv.AvailSuppression, value); err != nil {
return err
}
case "Bumper":
if err := awsRestjson1_deserializeDocumentBumper(&sv.Bumper, value); err != nil {
return err
}
case "CdnConfiguration":
if err := awsRestjson1_deserializeDocumentCdnConfiguration(&sv.CdnConfiguration, value); err != nil {
return err
}
case "ConfigurationAliases":
if err := awsRestjson1_deserializeDocumentConfigurationAliasesResponse(&sv.ConfigurationAliases, value); err != nil {
return err
}
case "DashConfiguration":
if err := awsRestjson1_deserializeDocumentDashConfiguration(&sv.DashConfiguration, value); err != nil {
return err
}
case "HlsConfiguration":
if err := awsRestjson1_deserializeDocumentHlsConfiguration(&sv.HlsConfiguration, value); err != nil {
return err
}
case "LivePreRollConfiguration":
if err := awsRestjson1_deserializeDocumentLivePreRollConfiguration(&sv.LivePreRollConfiguration, value); err != nil {
return err
}
case "LogConfiguration":
if err := awsRestjson1_deserializeDocumentLogConfiguration(&sv.LogConfiguration, value); err != nil {
return err
}
case "ManifestProcessingRules":
if err := awsRestjson1_deserializeDocumentManifestProcessingRules(&sv.ManifestProcessingRules, value); err != nil {
return err
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "PersonalizationThresholdSeconds":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __integerMin1 to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.PersonalizationThresholdSeconds = int32(i64)
}
case "PlaybackConfigurationArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.PlaybackConfigurationArn = ptr.String(jtv)
}
case "PlaybackEndpointPrefix":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.PlaybackEndpointPrefix = ptr.String(jtv)
}
case "SessionInitializationEndpointPrefix":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SessionInitializationEndpointPrefix = ptr.String(jtv)
}
case "SlateAdUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SlateAdUrl = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
case "TranscodeProfileName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.TranscodeProfileName = ptr.String(jtv)
}
case "VideoContentSourceUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.VideoContentSourceUrl = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPrefetchConsumption(v **types.PrefetchConsumption, 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.PrefetchConsumption
if *v == nil {
sv = &types.PrefetchConsumption{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AvailMatchingCriteria":
if err := awsRestjson1_deserializeDocument__listOfAvailMatchingCriteria(&sv.AvailMatchingCriteria, value); err != nil {
return err
}
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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPrefetchRetrieval(v **types.PrefetchRetrieval, 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.PrefetchRetrieval
if *v == nil {
sv = &types.PrefetchRetrieval{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "DynamicVariables":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.DynamicVariables, value); err != nil {
return err
}
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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPrefetchSchedule(v **types.PrefetchSchedule, 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.PrefetchSchedule
if *v == nil {
sv = &types.PrefetchSchedule{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "Consumption":
if err := awsRestjson1_deserializeDocumentPrefetchConsumption(&sv.Consumption, value); err != nil {
return err
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "PlaybackConfigurationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.PlaybackConfigurationName = ptr.String(jtv)
}
case "Retrieval":
if err := awsRestjson1_deserializeDocumentPrefetchRetrieval(&sv.Retrieval, value); err != nil {
return err
}
case "StreamId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.StreamId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResponseOutputItem(v **types.ResponseOutputItem, 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.ResponseOutputItem
if *v == nil {
sv = &types.ResponseOutputItem{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "DashPlaylistSettings":
if err := awsRestjson1_deserializeDocumentDashPlaylistSettings(&sv.DashPlaylistSettings, value); err != nil {
return err
}
case "HlsPlaylistSettings":
if err := awsRestjson1_deserializeDocumentHlsPlaylistSettings(&sv.HlsPlaylistSettings, value); err != nil {
return err
}
case "ManifestName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.ManifestName = ptr.String(jtv)
}
case "PlaybackUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.PlaybackUrl = ptr.String(jtv)
}
case "SourceGroup":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceGroup = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResponseOutputs(v *[]types.ResponseOutputItem, 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.ResponseOutputItem
if *v == nil {
cv = []types.ResponseOutputItem{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ResponseOutputItem
destAddr := &col
if err := awsRestjson1_deserializeDocumentResponseOutputItem(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentScheduleAdBreak(v **types.ScheduleAdBreak, 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.ScheduleAdBreak
if *v == nil {
sv = &types.ScheduleAdBreak{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ApproximateDurationSeconds":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __long to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.ApproximateDurationSeconds = i64
}
case "ApproximateStartTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.ApproximateStartTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "SourceLocationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceLocationName = ptr.String(jtv)
}
case "VodSourceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.VodSourceName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentScheduleEntry(v **types.ScheduleEntry, 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.ScheduleEntry
if *v == nil {
sv = &types.ScheduleEntry{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ApproximateDurationSeconds":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __long to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.ApproximateDurationSeconds = i64
}
case "ApproximateStartTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.ApproximateStartTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "ChannelName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.ChannelName = ptr.String(jtv)
}
case "LiveSourceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.LiveSourceName = ptr.String(jtv)
}
case "ProgramName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.ProgramName = ptr.String(jtv)
}
case "ScheduleAdBreaks":
if err := awsRestjson1_deserializeDocument__listOfScheduleAdBreak(&sv.ScheduleAdBreaks, value); err != nil {
return err
}
case "ScheduleEntryType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ScheduleEntryType to be of type string, got %T instead", value)
}
sv.ScheduleEntryType = types.ScheduleEntryType(jtv)
}
case "SourceLocationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceLocationName = ptr.String(jtv)
}
case "VodSourceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.VodSourceName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSecretsManagerAccessTokenConfiguration(v **types.SecretsManagerAccessTokenConfiguration, 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.SecretsManagerAccessTokenConfiguration
if *v == nil {
sv = &types.SecretsManagerAccessTokenConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "HeaderName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.HeaderName = ptr.String(jtv)
}
case "SecretArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SecretArn = ptr.String(jtv)
}
case "SecretStringKey":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SecretStringKey = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSegmentationDescriptor(v **types.SegmentationDescriptor, 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.SegmentationDescriptor
if *v == nil {
sv = &types.SegmentationDescriptor{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "SegmentationEventId":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.SegmentationEventId = ptr.Int32(int32(i64))
}
case "SegmentationTypeId":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.SegmentationTypeId = ptr.Int32(int32(i64))
}
case "SegmentationUpid":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.SegmentationUpid = ptr.String(jtv)
}
case "SegmentationUpidType":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.SegmentationUpidType = ptr.Int32(int32(i64))
}
case "SegmentNum":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.SegmentNum = ptr.Int32(int32(i64))
}
case "SegmentsExpected":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.SegmentsExpected = ptr.Int32(int32(i64))
}
case "SubSegmentNum":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.SubSegmentNum = ptr.Int32(int32(i64))
}
case "SubSegmentsExpected":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.SubSegmentsExpected = ptr.Int32(int32(i64))
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSegmentationDescriptorList(v *[]types.SegmentationDescriptor, 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.SegmentationDescriptor
if *v == nil {
cv = []types.SegmentationDescriptor{}
} else {
cv = *v
}
for _, value := range shape {
var col types.SegmentationDescriptor
destAddr := &col
if err := awsRestjson1_deserializeDocumentSegmentationDescriptor(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentSegmentDeliveryConfiguration(v **types.SegmentDeliveryConfiguration, 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.SegmentDeliveryConfiguration
if *v == nil {
sv = &types.SegmentDeliveryConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "BaseUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.BaseUrl = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSlateSource(v **types.SlateSource, 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.SlateSource
if *v == nil {
sv = &types.SlateSource{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "SourceLocationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceLocationName = ptr.String(jtv)
}
case "VodSourceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.VodSourceName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSourceLocation(v **types.SourceLocation, 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.SourceLocation
if *v == nil {
sv = &types.SourceLocation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AccessConfiguration":
if err := awsRestjson1_deserializeDocumentAccessConfiguration(&sv.AccessConfiguration, value); err != nil {
return err
}
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "DefaultSegmentDeliveryConfiguration":
if err := awsRestjson1_deserializeDocumentDefaultSegmentDeliveryConfiguration(&sv.DefaultSegmentDeliveryConfiguration, value); err != nil {
return err
}
case "HttpConfiguration":
if err := awsRestjson1_deserializeDocumentHttpConfiguration(&sv.HttpConfiguration, value); err != nil {
return err
}
case "LastModifiedTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "SegmentDeliveryConfigurations":
if err := awsRestjson1_deserializeDocument__listOfSegmentDeliveryConfiguration(&sv.SegmentDeliveryConfigurations, value); err != nil {
return err
}
case "SourceLocationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceLocationName = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSpliceInsertMessage(v **types.SpliceInsertMessage, 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.SpliceInsertMessage
if *v == nil {
sv = &types.SpliceInsertMessage{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AvailNum":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.AvailNum = int32(i64)
}
case "AvailsExpected":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.AvailsExpected = int32(i64)
}
case "SpliceEventId":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.SpliceEventId = int32(i64)
}
case "UniqueProgramId":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected __integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.UniqueProgramId = int32(i64)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTimeSignalMessage(v **types.TimeSignalMessage, 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.TimeSignalMessage
if *v == nil {
sv = &types.TimeSignalMessage{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "SegmentationDescriptors":
if err := awsRestjson1_deserializeDocumentSegmentationDescriptorList(&sv.SegmentationDescriptors, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentVodSource(v **types.VodSource, 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.VodSource
if *v == nil {
sv = &types.VodSource{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "CreationTime":
if value != nil {
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 __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "HttpPackageConfigurations":
if err := awsRestjson1_deserializeDocumentHttpPackageConfigurations(&sv.HttpPackageConfigurations, value); err != nil {
return err
}
case "LastModifiedTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected __timestampUnix to be a JSON Number, got %T instead", value)
}
}
case "SourceLocationName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.SourceLocationName = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocument__mapOf__string(&sv.Tags, value); err != nil {
return err
}
case "VodSourceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected __string to be of type string, got %T instead", value)
}
sv.VodSourceName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
| 10,397 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package mediatailor provides the API client, operations, and parameter types
// for AWS MediaTailor.
//
// Use the AWS Elemental MediaTailor SDKs and CLI to configure scalable ad
// insertion and linear channels. With MediaTailor, you can assemble existing
// content into a linear stream and serve targeted ads to viewers while maintaining
// broadcast quality in over-the-top (OTT) video applications. For information
// about using the service, including detailed information about the settings
// covered in this guide, see the AWS Elemental MediaTailor User Guide (https://docs.aws.amazon.com/mediatailor/latest/ug/)
// . Through the SDKs and the CLI you manage AWS Elemental MediaTailor
// configurations and channels the same as you do through the console. For example,
// you specify ad insertion behavior and mapping information for the origin server
// and the ad decision server (ADS).
package mediatailor
| 17 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mediatailor
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/mediatailor/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 = "mediatailor"
}
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 mediatailor
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.23.2"
| 7 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mediatailor
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mediatailor
import (
"bytes"
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/mediatailor/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/encoding/httpbinding"
smithyjson "github.com/aws/smithy-go/encoding/json"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
type awsRestjson1_serializeOpConfigureLogsForChannel struct {
}
func (*awsRestjson1_serializeOpConfigureLogsForChannel) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpConfigureLogsForChannel) 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.(*ConfigureLogsForChannelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/configureLogs/channel")
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_serializeOpDocumentConfigureLogsForChannelInput(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_serializeOpHttpBindingsConfigureLogsForChannelInput(v *ConfigureLogsForChannelInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentConfigureLogsForChannelInput(v *ConfigureLogsForChannelInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ChannelName != nil {
ok := object.Key("ChannelName")
ok.String(*v.ChannelName)
}
if v.LogTypes != nil {
ok := object.Key("LogTypes")
if err := awsRestjson1_serializeDocumentLogTypes(v.LogTypes, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpConfigureLogsForPlaybackConfiguration struct {
}
func (*awsRestjson1_serializeOpConfigureLogsForPlaybackConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpConfigureLogsForPlaybackConfiguration) 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.(*ConfigureLogsForPlaybackConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/configureLogs/playbackConfiguration")
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_serializeOpDocumentConfigureLogsForPlaybackConfigurationInput(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_serializeOpHttpBindingsConfigureLogsForPlaybackConfigurationInput(v *ConfigureLogsForPlaybackConfigurationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentConfigureLogsForPlaybackConfigurationInput(v *ConfigureLogsForPlaybackConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
{
ok := object.Key("PercentEnabled")
ok.Integer(v.PercentEnabled)
}
if v.PlaybackConfigurationName != nil {
ok := object.Key("PlaybackConfigurationName")
ok.String(*v.PlaybackConfigurationName)
}
return nil
}
type awsRestjson1_serializeOpCreateChannel struct {
}
func (*awsRestjson1_serializeOpCreateChannel) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateChannel) 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.(*CreateChannelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/channel/{ChannelName}")
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_serializeOpHttpBindingsCreateChannelInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateChannelInput(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_serializeOpHttpBindingsCreateChannelInput(v *CreateChannelInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ChannelName == nil || len(*v.ChannelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ChannelName must not be empty")}
}
if v.ChannelName != nil {
if err := encoder.SetURI("ChannelName").String(*v.ChannelName); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateChannelInput(v *CreateChannelInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FillerSlate != nil {
ok := object.Key("FillerSlate")
if err := awsRestjson1_serializeDocumentSlateSource(v.FillerSlate, ok); err != nil {
return err
}
}
if v.Outputs != nil {
ok := object.Key("Outputs")
if err := awsRestjson1_serializeDocumentRequestOutputs(v.Outputs, ok); err != nil {
return err
}
}
if len(v.PlaybackMode) > 0 {
ok := object.Key("PlaybackMode")
ok.String(string(v.PlaybackMode))
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocument__mapOf__string(v.Tags, ok); err != nil {
return err
}
}
if len(v.Tier) > 0 {
ok := object.Key("Tier")
ok.String(string(v.Tier))
}
return nil
}
type awsRestjson1_serializeOpCreateLiveSource struct {
}
func (*awsRestjson1_serializeOpCreateLiveSource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateLiveSource) 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.(*CreateLiveSourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sourceLocation/{SourceLocationName}/liveSource/{LiveSourceName}")
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_serializeOpHttpBindingsCreateLiveSourceInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateLiveSourceInput(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_serializeOpHttpBindingsCreateLiveSourceInput(v *CreateLiveSourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.LiveSourceName == nil || len(*v.LiveSourceName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member LiveSourceName must not be empty")}
}
if v.LiveSourceName != nil {
if err := encoder.SetURI("LiveSourceName").String(*v.LiveSourceName); err != nil {
return err
}
}
if v.SourceLocationName == nil || len(*v.SourceLocationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member SourceLocationName must not be empty")}
}
if v.SourceLocationName != nil {
if err := encoder.SetURI("SourceLocationName").String(*v.SourceLocationName); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateLiveSourceInput(v *CreateLiveSourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.HttpPackageConfigurations != nil {
ok := object.Key("HttpPackageConfigurations")
if err := awsRestjson1_serializeDocumentHttpPackageConfigurations(v.HttpPackageConfigurations, ok); err != nil {
return err
}
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocument__mapOf__string(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreatePrefetchSchedule struct {
}
func (*awsRestjson1_serializeOpCreatePrefetchSchedule) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreatePrefetchSchedule) 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.(*CreatePrefetchScheduleInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/prefetchSchedule/{PlaybackConfigurationName}/{Name}")
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_serializeOpHttpBindingsCreatePrefetchScheduleInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreatePrefetchScheduleInput(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_serializeOpHttpBindingsCreatePrefetchScheduleInput(v *CreatePrefetchScheduleInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Name == nil || len(*v.Name) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")}
}
if v.Name != nil {
if err := encoder.SetURI("Name").String(*v.Name); err != nil {
return err
}
}
if v.PlaybackConfigurationName == nil || len(*v.PlaybackConfigurationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member PlaybackConfigurationName must not be empty")}
}
if v.PlaybackConfigurationName != nil {
if err := encoder.SetURI("PlaybackConfigurationName").String(*v.PlaybackConfigurationName); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentCreatePrefetchScheduleInput(v *CreatePrefetchScheduleInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Consumption != nil {
ok := object.Key("Consumption")
if err := awsRestjson1_serializeDocumentPrefetchConsumption(v.Consumption, ok); err != nil {
return err
}
}
if v.Retrieval != nil {
ok := object.Key("Retrieval")
if err := awsRestjson1_serializeDocumentPrefetchRetrieval(v.Retrieval, ok); err != nil {
return err
}
}
if v.StreamId != nil {
ok := object.Key("StreamId")
ok.String(*v.StreamId)
}
return nil
}
type awsRestjson1_serializeOpCreateProgram struct {
}
func (*awsRestjson1_serializeOpCreateProgram) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateProgram) 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.(*CreateProgramInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/channel/{ChannelName}/program/{ProgramName}")
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_serializeOpHttpBindingsCreateProgramInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateProgramInput(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_serializeOpHttpBindingsCreateProgramInput(v *CreateProgramInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ChannelName == nil || len(*v.ChannelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ChannelName must not be empty")}
}
if v.ChannelName != nil {
if err := encoder.SetURI("ChannelName").String(*v.ChannelName); err != nil {
return err
}
}
if v.ProgramName == nil || len(*v.ProgramName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ProgramName must not be empty")}
}
if v.ProgramName != nil {
if err := encoder.SetURI("ProgramName").String(*v.ProgramName); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateProgramInput(v *CreateProgramInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AdBreaks != nil {
ok := object.Key("AdBreaks")
if err := awsRestjson1_serializeDocument__listOfAdBreak(v.AdBreaks, ok); err != nil {
return err
}
}
if v.LiveSourceName != nil {
ok := object.Key("LiveSourceName")
ok.String(*v.LiveSourceName)
}
if v.ScheduleConfiguration != nil {
ok := object.Key("ScheduleConfiguration")
if err := awsRestjson1_serializeDocumentScheduleConfiguration(v.ScheduleConfiguration, ok); err != nil {
return err
}
}
if v.SourceLocationName != nil {
ok := object.Key("SourceLocationName")
ok.String(*v.SourceLocationName)
}
if v.VodSourceName != nil {
ok := object.Key("VodSourceName")
ok.String(*v.VodSourceName)
}
return nil
}
type awsRestjson1_serializeOpCreateSourceLocation struct {
}
func (*awsRestjson1_serializeOpCreateSourceLocation) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateSourceLocation) 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.(*CreateSourceLocationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sourceLocation/{SourceLocationName}")
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_serializeOpHttpBindingsCreateSourceLocationInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateSourceLocationInput(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_serializeOpHttpBindingsCreateSourceLocationInput(v *CreateSourceLocationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SourceLocationName == nil || len(*v.SourceLocationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member SourceLocationName must not be empty")}
}
if v.SourceLocationName != nil {
if err := encoder.SetURI("SourceLocationName").String(*v.SourceLocationName); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateSourceLocationInput(v *CreateSourceLocationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccessConfiguration != nil {
ok := object.Key("AccessConfiguration")
if err := awsRestjson1_serializeDocumentAccessConfiguration(v.AccessConfiguration, ok); err != nil {
return err
}
}
if v.DefaultSegmentDeliveryConfiguration != nil {
ok := object.Key("DefaultSegmentDeliveryConfiguration")
if err := awsRestjson1_serializeDocumentDefaultSegmentDeliveryConfiguration(v.DefaultSegmentDeliveryConfiguration, ok); err != nil {
return err
}
}
if v.HttpConfiguration != nil {
ok := object.Key("HttpConfiguration")
if err := awsRestjson1_serializeDocumentHttpConfiguration(v.HttpConfiguration, ok); err != nil {
return err
}
}
if v.SegmentDeliveryConfigurations != nil {
ok := object.Key("SegmentDeliveryConfigurations")
if err := awsRestjson1_serializeDocument__listOfSegmentDeliveryConfiguration(v.SegmentDeliveryConfigurations, ok); err != nil {
return err
}
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocument__mapOf__string(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateVodSource struct {
}
func (*awsRestjson1_serializeOpCreateVodSource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateVodSource) 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.(*CreateVodSourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sourceLocation/{SourceLocationName}/vodSource/{VodSourceName}")
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_serializeOpHttpBindingsCreateVodSourceInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateVodSourceInput(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_serializeOpHttpBindingsCreateVodSourceInput(v *CreateVodSourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SourceLocationName == nil || len(*v.SourceLocationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member SourceLocationName must not be empty")}
}
if v.SourceLocationName != nil {
if err := encoder.SetURI("SourceLocationName").String(*v.SourceLocationName); err != nil {
return err
}
}
if v.VodSourceName == nil || len(*v.VodSourceName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member VodSourceName must not be empty")}
}
if v.VodSourceName != nil {
if err := encoder.SetURI("VodSourceName").String(*v.VodSourceName); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateVodSourceInput(v *CreateVodSourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.HttpPackageConfigurations != nil {
ok := object.Key("HttpPackageConfigurations")
if err := awsRestjson1_serializeDocumentHttpPackageConfigurations(v.HttpPackageConfigurations, ok); err != nil {
return err
}
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocument__mapOf__string(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteChannel struct {
}
func (*awsRestjson1_serializeOpDeleteChannel) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteChannel) 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.(*DeleteChannelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/channel/{ChannelName}")
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_serializeOpHttpBindingsDeleteChannelInput(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_serializeOpHttpBindingsDeleteChannelInput(v *DeleteChannelInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ChannelName == nil || len(*v.ChannelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ChannelName must not be empty")}
}
if v.ChannelName != nil {
if err := encoder.SetURI("ChannelName").String(*v.ChannelName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteChannelPolicy struct {
}
func (*awsRestjson1_serializeOpDeleteChannelPolicy) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteChannelPolicy) 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.(*DeleteChannelPolicyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/channel/{ChannelName}/policy")
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_serializeOpHttpBindingsDeleteChannelPolicyInput(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_serializeOpHttpBindingsDeleteChannelPolicyInput(v *DeleteChannelPolicyInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ChannelName == nil || len(*v.ChannelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ChannelName must not be empty")}
}
if v.ChannelName != nil {
if err := encoder.SetURI("ChannelName").String(*v.ChannelName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteLiveSource struct {
}
func (*awsRestjson1_serializeOpDeleteLiveSource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteLiveSource) 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.(*DeleteLiveSourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sourceLocation/{SourceLocationName}/liveSource/{LiveSourceName}")
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_serializeOpHttpBindingsDeleteLiveSourceInput(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_serializeOpHttpBindingsDeleteLiveSourceInput(v *DeleteLiveSourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.LiveSourceName == nil || len(*v.LiveSourceName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member LiveSourceName must not be empty")}
}
if v.LiveSourceName != nil {
if err := encoder.SetURI("LiveSourceName").String(*v.LiveSourceName); err != nil {
return err
}
}
if v.SourceLocationName == nil || len(*v.SourceLocationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member SourceLocationName must not be empty")}
}
if v.SourceLocationName != nil {
if err := encoder.SetURI("SourceLocationName").String(*v.SourceLocationName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeletePlaybackConfiguration struct {
}
func (*awsRestjson1_serializeOpDeletePlaybackConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeletePlaybackConfiguration) 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.(*DeletePlaybackConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/playbackConfiguration/{Name}")
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_serializeOpHttpBindingsDeletePlaybackConfigurationInput(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_serializeOpHttpBindingsDeletePlaybackConfigurationInput(v *DeletePlaybackConfigurationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Name == nil || len(*v.Name) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")}
}
if v.Name != nil {
if err := encoder.SetURI("Name").String(*v.Name); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeletePrefetchSchedule struct {
}
func (*awsRestjson1_serializeOpDeletePrefetchSchedule) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeletePrefetchSchedule) 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.(*DeletePrefetchScheduleInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/prefetchSchedule/{PlaybackConfigurationName}/{Name}")
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_serializeOpHttpBindingsDeletePrefetchScheduleInput(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_serializeOpHttpBindingsDeletePrefetchScheduleInput(v *DeletePrefetchScheduleInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Name == nil || len(*v.Name) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")}
}
if v.Name != nil {
if err := encoder.SetURI("Name").String(*v.Name); err != nil {
return err
}
}
if v.PlaybackConfigurationName == nil || len(*v.PlaybackConfigurationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member PlaybackConfigurationName must not be empty")}
}
if v.PlaybackConfigurationName != nil {
if err := encoder.SetURI("PlaybackConfigurationName").String(*v.PlaybackConfigurationName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteProgram struct {
}
func (*awsRestjson1_serializeOpDeleteProgram) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteProgram) 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.(*DeleteProgramInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/channel/{ChannelName}/program/{ProgramName}")
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_serializeOpHttpBindingsDeleteProgramInput(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_serializeOpHttpBindingsDeleteProgramInput(v *DeleteProgramInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ChannelName == nil || len(*v.ChannelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ChannelName must not be empty")}
}
if v.ChannelName != nil {
if err := encoder.SetURI("ChannelName").String(*v.ChannelName); err != nil {
return err
}
}
if v.ProgramName == nil || len(*v.ProgramName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ProgramName must not be empty")}
}
if v.ProgramName != nil {
if err := encoder.SetURI("ProgramName").String(*v.ProgramName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteSourceLocation struct {
}
func (*awsRestjson1_serializeOpDeleteSourceLocation) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteSourceLocation) 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.(*DeleteSourceLocationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sourceLocation/{SourceLocationName}")
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_serializeOpHttpBindingsDeleteSourceLocationInput(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_serializeOpHttpBindingsDeleteSourceLocationInput(v *DeleteSourceLocationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SourceLocationName == nil || len(*v.SourceLocationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member SourceLocationName must not be empty")}
}
if v.SourceLocationName != nil {
if err := encoder.SetURI("SourceLocationName").String(*v.SourceLocationName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteVodSource struct {
}
func (*awsRestjson1_serializeOpDeleteVodSource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteVodSource) 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.(*DeleteVodSourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sourceLocation/{SourceLocationName}/vodSource/{VodSourceName}")
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_serializeOpHttpBindingsDeleteVodSourceInput(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_serializeOpHttpBindingsDeleteVodSourceInput(v *DeleteVodSourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SourceLocationName == nil || len(*v.SourceLocationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member SourceLocationName must not be empty")}
}
if v.SourceLocationName != nil {
if err := encoder.SetURI("SourceLocationName").String(*v.SourceLocationName); err != nil {
return err
}
}
if v.VodSourceName == nil || len(*v.VodSourceName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member VodSourceName must not be empty")}
}
if v.VodSourceName != nil {
if err := encoder.SetURI("VodSourceName").String(*v.VodSourceName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDescribeChannel struct {
}
func (*awsRestjson1_serializeOpDescribeChannel) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDescribeChannel) 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.(*DescribeChannelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/channel/{ChannelName}")
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_serializeOpHttpBindingsDescribeChannelInput(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_serializeOpHttpBindingsDescribeChannelInput(v *DescribeChannelInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ChannelName == nil || len(*v.ChannelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ChannelName must not be empty")}
}
if v.ChannelName != nil {
if err := encoder.SetURI("ChannelName").String(*v.ChannelName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDescribeLiveSource struct {
}
func (*awsRestjson1_serializeOpDescribeLiveSource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDescribeLiveSource) 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.(*DescribeLiveSourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sourceLocation/{SourceLocationName}/liveSource/{LiveSourceName}")
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_serializeOpHttpBindingsDescribeLiveSourceInput(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_serializeOpHttpBindingsDescribeLiveSourceInput(v *DescribeLiveSourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.LiveSourceName == nil || len(*v.LiveSourceName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member LiveSourceName must not be empty")}
}
if v.LiveSourceName != nil {
if err := encoder.SetURI("LiveSourceName").String(*v.LiveSourceName); err != nil {
return err
}
}
if v.SourceLocationName == nil || len(*v.SourceLocationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member SourceLocationName must not be empty")}
}
if v.SourceLocationName != nil {
if err := encoder.SetURI("SourceLocationName").String(*v.SourceLocationName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDescribeProgram struct {
}
func (*awsRestjson1_serializeOpDescribeProgram) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDescribeProgram) 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.(*DescribeProgramInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/channel/{ChannelName}/program/{ProgramName}")
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_serializeOpHttpBindingsDescribeProgramInput(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_serializeOpHttpBindingsDescribeProgramInput(v *DescribeProgramInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ChannelName == nil || len(*v.ChannelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ChannelName must not be empty")}
}
if v.ChannelName != nil {
if err := encoder.SetURI("ChannelName").String(*v.ChannelName); err != nil {
return err
}
}
if v.ProgramName == nil || len(*v.ProgramName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ProgramName must not be empty")}
}
if v.ProgramName != nil {
if err := encoder.SetURI("ProgramName").String(*v.ProgramName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDescribeSourceLocation struct {
}
func (*awsRestjson1_serializeOpDescribeSourceLocation) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDescribeSourceLocation) 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.(*DescribeSourceLocationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sourceLocation/{SourceLocationName}")
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_serializeOpHttpBindingsDescribeSourceLocationInput(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_serializeOpHttpBindingsDescribeSourceLocationInput(v *DescribeSourceLocationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SourceLocationName == nil || len(*v.SourceLocationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member SourceLocationName must not be empty")}
}
if v.SourceLocationName != nil {
if err := encoder.SetURI("SourceLocationName").String(*v.SourceLocationName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDescribeVodSource struct {
}
func (*awsRestjson1_serializeOpDescribeVodSource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDescribeVodSource) 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.(*DescribeVodSourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sourceLocation/{SourceLocationName}/vodSource/{VodSourceName}")
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_serializeOpHttpBindingsDescribeVodSourceInput(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_serializeOpHttpBindingsDescribeVodSourceInput(v *DescribeVodSourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SourceLocationName == nil || len(*v.SourceLocationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member SourceLocationName must not be empty")}
}
if v.SourceLocationName != nil {
if err := encoder.SetURI("SourceLocationName").String(*v.SourceLocationName); err != nil {
return err
}
}
if v.VodSourceName == nil || len(*v.VodSourceName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member VodSourceName must not be empty")}
}
if v.VodSourceName != nil {
if err := encoder.SetURI("VodSourceName").String(*v.VodSourceName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetChannelPolicy struct {
}
func (*awsRestjson1_serializeOpGetChannelPolicy) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetChannelPolicy) 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.(*GetChannelPolicyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/channel/{ChannelName}/policy")
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_serializeOpHttpBindingsGetChannelPolicyInput(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_serializeOpHttpBindingsGetChannelPolicyInput(v *GetChannelPolicyInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ChannelName == nil || len(*v.ChannelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ChannelName must not be empty")}
}
if v.ChannelName != nil {
if err := encoder.SetURI("ChannelName").String(*v.ChannelName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetChannelSchedule struct {
}
func (*awsRestjson1_serializeOpGetChannelSchedule) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetChannelSchedule) 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.(*GetChannelScheduleInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/channel/{ChannelName}/schedule")
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_serializeOpHttpBindingsGetChannelScheduleInput(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_serializeOpHttpBindingsGetChannelScheduleInput(v *GetChannelScheduleInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ChannelName == nil || len(*v.ChannelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ChannelName must not be empty")}
}
if v.ChannelName != nil {
if err := encoder.SetURI("ChannelName").String(*v.ChannelName); err != nil {
return err
}
}
if v.DurationMinutes != nil {
encoder.SetQuery("durationMinutes").String(*v.DurationMinutes)
}
if v.MaxResults != 0 {
encoder.SetQuery("maxResults").Integer(v.MaxResults)
}
if v.NextToken != nil {
encoder.SetQuery("nextToken").String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpGetPlaybackConfiguration struct {
}
func (*awsRestjson1_serializeOpGetPlaybackConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetPlaybackConfiguration) 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.(*GetPlaybackConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/playbackConfiguration/{Name}")
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_serializeOpHttpBindingsGetPlaybackConfigurationInput(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_serializeOpHttpBindingsGetPlaybackConfigurationInput(v *GetPlaybackConfigurationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Name == nil || len(*v.Name) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")}
}
if v.Name != nil {
if err := encoder.SetURI("Name").String(*v.Name); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpGetPrefetchSchedule struct {
}
func (*awsRestjson1_serializeOpGetPrefetchSchedule) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetPrefetchSchedule) 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.(*GetPrefetchScheduleInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/prefetchSchedule/{PlaybackConfigurationName}/{Name}")
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_serializeOpHttpBindingsGetPrefetchScheduleInput(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_serializeOpHttpBindingsGetPrefetchScheduleInput(v *GetPrefetchScheduleInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.Name == nil || len(*v.Name) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")}
}
if v.Name != nil {
if err := encoder.SetURI("Name").String(*v.Name); err != nil {
return err
}
}
if v.PlaybackConfigurationName == nil || len(*v.PlaybackConfigurationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member PlaybackConfigurationName must not be empty")}
}
if v.PlaybackConfigurationName != nil {
if err := encoder.SetURI("PlaybackConfigurationName").String(*v.PlaybackConfigurationName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListAlerts struct {
}
func (*awsRestjson1_serializeOpListAlerts) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListAlerts) 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.(*ListAlertsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/alerts")
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_serializeOpHttpBindingsListAlertsInput(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_serializeOpHttpBindingsListAlertsInput(v *ListAlertsInput, 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.ResourceArn != nil {
encoder.SetQuery("resourceArn").String(*v.ResourceArn)
}
return nil
}
type awsRestjson1_serializeOpListChannels struct {
}
func (*awsRestjson1_serializeOpListChannels) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListChannels) 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.(*ListChannelsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/channels")
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_serializeOpHttpBindingsListChannelsInput(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_serializeOpHttpBindingsListChannelsInput(v *ListChannelsInput, 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_serializeOpListLiveSources struct {
}
func (*awsRestjson1_serializeOpListLiveSources) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListLiveSources) 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.(*ListLiveSourcesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sourceLocation/{SourceLocationName}/liveSources")
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_serializeOpHttpBindingsListLiveSourcesInput(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_serializeOpHttpBindingsListLiveSourcesInput(v *ListLiveSourcesInput, 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.SourceLocationName == nil || len(*v.SourceLocationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member SourceLocationName must not be empty")}
}
if v.SourceLocationName != nil {
if err := encoder.SetURI("SourceLocationName").String(*v.SourceLocationName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListPlaybackConfigurations struct {
}
func (*awsRestjson1_serializeOpListPlaybackConfigurations) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListPlaybackConfigurations) 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.(*ListPlaybackConfigurationsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/playbackConfigurations")
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_serializeOpHttpBindingsListPlaybackConfigurationsInput(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_serializeOpHttpBindingsListPlaybackConfigurationsInput(v *ListPlaybackConfigurationsInput, 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_serializeOpListPrefetchSchedules struct {
}
func (*awsRestjson1_serializeOpListPrefetchSchedules) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListPrefetchSchedules) 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.(*ListPrefetchSchedulesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/prefetchSchedule/{PlaybackConfigurationName}")
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_serializeOpHttpBindingsListPrefetchSchedulesInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListPrefetchSchedulesInput(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_serializeOpHttpBindingsListPrefetchSchedulesInput(v *ListPrefetchSchedulesInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.PlaybackConfigurationName == nil || len(*v.PlaybackConfigurationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member PlaybackConfigurationName must not be empty")}
}
if v.PlaybackConfigurationName != nil {
if err := encoder.SetURI("PlaybackConfigurationName").String(*v.PlaybackConfigurationName); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentListPrefetchSchedulesInput(v *ListPrefetchSchedulesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MaxResults != 0 {
ok := object.Key("MaxResults")
ok.Integer(v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.StreamId != nil {
ok := object.Key("StreamId")
ok.String(*v.StreamId)
}
return nil
}
type awsRestjson1_serializeOpListSourceLocations struct {
}
func (*awsRestjson1_serializeOpListSourceLocations) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListSourceLocations) 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.(*ListSourceLocationsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sourceLocations")
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_serializeOpHttpBindingsListSourceLocationsInput(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_serializeOpHttpBindingsListSourceLocationsInput(v *ListSourceLocationsInput, 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_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_serializeOpListVodSources struct {
}
func (*awsRestjson1_serializeOpListVodSources) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListVodSources) 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.(*ListVodSourcesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sourceLocation/{SourceLocationName}/vodSources")
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_serializeOpHttpBindingsListVodSourcesInput(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_serializeOpHttpBindingsListVodSourcesInput(v *ListVodSourcesInput, 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.SourceLocationName == nil || len(*v.SourceLocationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member SourceLocationName must not be empty")}
}
if v.SourceLocationName != nil {
if err := encoder.SetURI("SourceLocationName").String(*v.SourceLocationName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpPutChannelPolicy struct {
}
func (*awsRestjson1_serializeOpPutChannelPolicy) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpPutChannelPolicy) 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.(*PutChannelPolicyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/channel/{ChannelName}/policy")
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_serializeOpHttpBindingsPutChannelPolicyInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentPutChannelPolicyInput(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_serializeOpHttpBindingsPutChannelPolicyInput(v *PutChannelPolicyInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ChannelName == nil || len(*v.ChannelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ChannelName must not be empty")}
}
if v.ChannelName != nil {
if err := encoder.SetURI("ChannelName").String(*v.ChannelName); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentPutChannelPolicyInput(v *PutChannelPolicyInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Policy != nil {
ok := object.Key("Policy")
ok.String(*v.Policy)
}
return nil
}
type awsRestjson1_serializeOpPutPlaybackConfiguration struct {
}
func (*awsRestjson1_serializeOpPutPlaybackConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpPutPlaybackConfiguration) 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.(*PutPlaybackConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/playbackConfiguration")
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_serializeOpDocumentPutPlaybackConfigurationInput(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_serializeOpHttpBindingsPutPlaybackConfigurationInput(v *PutPlaybackConfigurationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentPutPlaybackConfigurationInput(v *PutPlaybackConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AdDecisionServerUrl != nil {
ok := object.Key("AdDecisionServerUrl")
ok.String(*v.AdDecisionServerUrl)
}
if v.AvailSuppression != nil {
ok := object.Key("AvailSuppression")
if err := awsRestjson1_serializeDocumentAvailSuppression(v.AvailSuppression, ok); err != nil {
return err
}
}
if v.Bumper != nil {
ok := object.Key("Bumper")
if err := awsRestjson1_serializeDocumentBumper(v.Bumper, ok); err != nil {
return err
}
}
if v.CdnConfiguration != nil {
ok := object.Key("CdnConfiguration")
if err := awsRestjson1_serializeDocumentCdnConfiguration(v.CdnConfiguration, ok); err != nil {
return err
}
}
if v.ConfigurationAliases != nil {
ok := object.Key("ConfigurationAliases")
if err := awsRestjson1_serializeDocumentConfigurationAliasesRequest(v.ConfigurationAliases, ok); err != nil {
return err
}
}
if v.DashConfiguration != nil {
ok := object.Key("DashConfiguration")
if err := awsRestjson1_serializeDocumentDashConfigurationForPut(v.DashConfiguration, ok); err != nil {
return err
}
}
if v.LivePreRollConfiguration != nil {
ok := object.Key("LivePreRollConfiguration")
if err := awsRestjson1_serializeDocumentLivePreRollConfiguration(v.LivePreRollConfiguration, ok); err != nil {
return err
}
}
if v.ManifestProcessingRules != nil {
ok := object.Key("ManifestProcessingRules")
if err := awsRestjson1_serializeDocumentManifestProcessingRules(v.ManifestProcessingRules, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.PersonalizationThresholdSeconds != 0 {
ok := object.Key("PersonalizationThresholdSeconds")
ok.Integer(v.PersonalizationThresholdSeconds)
}
if v.SlateAdUrl != nil {
ok := object.Key("SlateAdUrl")
ok.String(*v.SlateAdUrl)
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocument__mapOf__string(v.Tags, ok); err != nil {
return err
}
}
if v.TranscodeProfileName != nil {
ok := object.Key("TranscodeProfileName")
ok.String(*v.TranscodeProfileName)
}
if v.VideoContentSourceUrl != nil {
ok := object.Key("VideoContentSourceUrl")
ok.String(*v.VideoContentSourceUrl)
}
return nil
}
type awsRestjson1_serializeOpStartChannel struct {
}
func (*awsRestjson1_serializeOpStartChannel) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStartChannel) 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.(*StartChannelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/channel/{ChannelName}/start")
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_serializeOpHttpBindingsStartChannelInput(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_serializeOpHttpBindingsStartChannelInput(v *StartChannelInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ChannelName == nil || len(*v.ChannelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ChannelName must not be empty")}
}
if v.ChannelName != nil {
if err := encoder.SetURI("ChannelName").String(*v.ChannelName); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpStopChannel struct {
}
func (*awsRestjson1_serializeOpStopChannel) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpStopChannel) 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.(*StopChannelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/channel/{ChannelName}/stop")
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_serializeOpHttpBindingsStopChannelInput(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_serializeOpHttpBindingsStopChannelInput(v *StopChannelInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ChannelName == nil || len(*v.ChannelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ChannelName must not be empty")}
}
if v.ChannelName != nil {
if err := encoder.SetURI("ChannelName").String(*v.ChannelName); 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_serializeDocument__mapOf__string(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_serializeOpUpdateChannel struct {
}
func (*awsRestjson1_serializeOpUpdateChannel) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateChannel) 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.(*UpdateChannelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/channel/{ChannelName}")
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_serializeOpHttpBindingsUpdateChannelInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateChannelInput(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_serializeOpHttpBindingsUpdateChannelInput(v *UpdateChannelInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ChannelName == nil || len(*v.ChannelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ChannelName must not be empty")}
}
if v.ChannelName != nil {
if err := encoder.SetURI("ChannelName").String(*v.ChannelName); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateChannelInput(v *UpdateChannelInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FillerSlate != nil {
ok := object.Key("FillerSlate")
if err := awsRestjson1_serializeDocumentSlateSource(v.FillerSlate, ok); err != nil {
return err
}
}
if v.Outputs != nil {
ok := object.Key("Outputs")
if err := awsRestjson1_serializeDocumentRequestOutputs(v.Outputs, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUpdateLiveSource struct {
}
func (*awsRestjson1_serializeOpUpdateLiveSource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateLiveSource) 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.(*UpdateLiveSourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sourceLocation/{SourceLocationName}/liveSource/{LiveSourceName}")
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_serializeOpHttpBindingsUpdateLiveSourceInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateLiveSourceInput(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_serializeOpHttpBindingsUpdateLiveSourceInput(v *UpdateLiveSourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.LiveSourceName == nil || len(*v.LiveSourceName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member LiveSourceName must not be empty")}
}
if v.LiveSourceName != nil {
if err := encoder.SetURI("LiveSourceName").String(*v.LiveSourceName); err != nil {
return err
}
}
if v.SourceLocationName == nil || len(*v.SourceLocationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member SourceLocationName must not be empty")}
}
if v.SourceLocationName != nil {
if err := encoder.SetURI("SourceLocationName").String(*v.SourceLocationName); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateLiveSourceInput(v *UpdateLiveSourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.HttpPackageConfigurations != nil {
ok := object.Key("HttpPackageConfigurations")
if err := awsRestjson1_serializeDocumentHttpPackageConfigurations(v.HttpPackageConfigurations, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUpdateProgram struct {
}
func (*awsRestjson1_serializeOpUpdateProgram) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateProgram) 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.(*UpdateProgramInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/channel/{ChannelName}/program/{ProgramName}")
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_serializeOpHttpBindingsUpdateProgramInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateProgramInput(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_serializeOpHttpBindingsUpdateProgramInput(v *UpdateProgramInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ChannelName == nil || len(*v.ChannelName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ChannelName must not be empty")}
}
if v.ChannelName != nil {
if err := encoder.SetURI("ChannelName").String(*v.ChannelName); err != nil {
return err
}
}
if v.ProgramName == nil || len(*v.ProgramName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member ProgramName must not be empty")}
}
if v.ProgramName != nil {
if err := encoder.SetURI("ProgramName").String(*v.ProgramName); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateProgramInput(v *UpdateProgramInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AdBreaks != nil {
ok := object.Key("AdBreaks")
if err := awsRestjson1_serializeDocument__listOfAdBreak(v.AdBreaks, ok); err != nil {
return err
}
}
if v.ScheduleConfiguration != nil {
ok := object.Key("ScheduleConfiguration")
if err := awsRestjson1_serializeDocumentUpdateProgramScheduleConfiguration(v.ScheduleConfiguration, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUpdateSourceLocation struct {
}
func (*awsRestjson1_serializeOpUpdateSourceLocation) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateSourceLocation) 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.(*UpdateSourceLocationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sourceLocation/{SourceLocationName}")
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_serializeOpHttpBindingsUpdateSourceLocationInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateSourceLocationInput(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_serializeOpHttpBindingsUpdateSourceLocationInput(v *UpdateSourceLocationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SourceLocationName == nil || len(*v.SourceLocationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member SourceLocationName must not be empty")}
}
if v.SourceLocationName != nil {
if err := encoder.SetURI("SourceLocationName").String(*v.SourceLocationName); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateSourceLocationInput(v *UpdateSourceLocationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccessConfiguration != nil {
ok := object.Key("AccessConfiguration")
if err := awsRestjson1_serializeDocumentAccessConfiguration(v.AccessConfiguration, ok); err != nil {
return err
}
}
if v.DefaultSegmentDeliveryConfiguration != nil {
ok := object.Key("DefaultSegmentDeliveryConfiguration")
if err := awsRestjson1_serializeDocumentDefaultSegmentDeliveryConfiguration(v.DefaultSegmentDeliveryConfiguration, ok); err != nil {
return err
}
}
if v.HttpConfiguration != nil {
ok := object.Key("HttpConfiguration")
if err := awsRestjson1_serializeDocumentHttpConfiguration(v.HttpConfiguration, ok); err != nil {
return err
}
}
if v.SegmentDeliveryConfigurations != nil {
ok := object.Key("SegmentDeliveryConfigurations")
if err := awsRestjson1_serializeDocument__listOfSegmentDeliveryConfiguration(v.SegmentDeliveryConfigurations, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUpdateVodSource struct {
}
func (*awsRestjson1_serializeOpUpdateVodSource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateVodSource) 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.(*UpdateVodSourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sourceLocation/{SourceLocationName}/vodSource/{VodSourceName}")
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_serializeOpHttpBindingsUpdateVodSourceInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateVodSourceInput(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_serializeOpHttpBindingsUpdateVodSourceInput(v *UpdateVodSourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.SourceLocationName == nil || len(*v.SourceLocationName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member SourceLocationName must not be empty")}
}
if v.SourceLocationName != nil {
if err := encoder.SetURI("SourceLocationName").String(*v.SourceLocationName); err != nil {
return err
}
}
if v.VodSourceName == nil || len(*v.VodSourceName) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member VodSourceName must not be empty")}
}
if v.VodSourceName != nil {
if err := encoder.SetURI("VodSourceName").String(*v.VodSourceName); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateVodSourceInput(v *UpdateVodSourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.HttpPackageConfigurations != nil {
ok := object.Key("HttpPackageConfigurations")
if err := awsRestjson1_serializeDocumentHttpPackageConfigurations(v.HttpPackageConfigurations, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocument__listOfAdBreak(v []types.AdBreak, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentAdBreak(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocument__listOfAvailMatchingCriteria(v []types.AvailMatchingCriteria, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentAvailMatchingCriteria(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocument__listOfSegmentDeliveryConfiguration(v []types.SegmentDeliveryConfiguration, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentSegmentDeliveryConfiguration(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocument__mapOf__string(v map[string]string, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
om.String(v[key])
}
return nil
}
func awsRestjson1_serializeDocumentAccessConfiguration(v *types.AccessConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.AccessType) > 0 {
ok := object.Key("AccessType")
ok.String(string(v.AccessType))
}
if v.SecretsManagerAccessTokenConfiguration != nil {
ok := object.Key("SecretsManagerAccessTokenConfiguration")
if err := awsRestjson1_serializeDocumentSecretsManagerAccessTokenConfiguration(v.SecretsManagerAccessTokenConfiguration, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentAdBreak(v *types.AdBreak, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.MessageType) > 0 {
ok := object.Key("MessageType")
ok.String(string(v.MessageType))
}
if v.OffsetMillis != 0 {
ok := object.Key("OffsetMillis")
ok.Long(v.OffsetMillis)
}
if v.Slate != nil {
ok := object.Key("Slate")
if err := awsRestjson1_serializeDocumentSlateSource(v.Slate, ok); err != nil {
return err
}
}
if v.SpliceInsertMessage != nil {
ok := object.Key("SpliceInsertMessage")
if err := awsRestjson1_serializeDocumentSpliceInsertMessage(v.SpliceInsertMessage, ok); err != nil {
return err
}
}
if v.TimeSignalMessage != nil {
ok := object.Key("TimeSignalMessage")
if err := awsRestjson1_serializeDocumentTimeSignalMessage(v.TimeSignalMessage, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentAdMarkerPassthrough(v *types.AdMarkerPassthrough, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Enabled {
ok := object.Key("Enabled")
ok.Boolean(v.Enabled)
}
return nil
}
func awsRestjson1_serializeDocumentAvailMatchingCriteria(v *types.AvailMatchingCriteria, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DynamicVariable != nil {
ok := object.Key("DynamicVariable")
ok.String(*v.DynamicVariable)
}
if len(v.Operator) > 0 {
ok := object.Key("Operator")
ok.String(string(v.Operator))
}
return nil
}
func awsRestjson1_serializeDocumentAvailSuppression(v *types.AvailSuppression, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.FillPolicy) > 0 {
ok := object.Key("FillPolicy")
ok.String(string(v.FillPolicy))
}
if len(v.Mode) > 0 {
ok := object.Key("Mode")
ok.String(string(v.Mode))
}
if v.Value != nil {
ok := object.Key("Value")
ok.String(*v.Value)
}
return nil
}
func awsRestjson1_serializeDocumentBumper(v *types.Bumper, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.EndUrl != nil {
ok := object.Key("EndUrl")
ok.String(*v.EndUrl)
}
if v.StartUrl != nil {
ok := object.Key("StartUrl")
ok.String(*v.StartUrl)
}
return nil
}
func awsRestjson1_serializeDocumentCdnConfiguration(v *types.CdnConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AdSegmentUrlPrefix != nil {
ok := object.Key("AdSegmentUrlPrefix")
ok.String(*v.AdSegmentUrlPrefix)
}
if v.ContentSegmentUrlPrefix != nil {
ok := object.Key("ContentSegmentUrlPrefix")
ok.String(*v.ContentSegmentUrlPrefix)
}
return nil
}
func awsRestjson1_serializeDocumentClipRange(v *types.ClipRange, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
{
ok := object.Key("EndOffsetMillis")
ok.Long(v.EndOffsetMillis)
}
return nil
}
func awsRestjson1_serializeDocumentConfigurationAliasesRequest(v map[string]map[string]string, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
if vv := v[key]; vv == nil {
continue
}
if err := awsRestjson1_serializeDocument__mapOf__string(v[key], om); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentDashConfigurationForPut(v *types.DashConfigurationForPut, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MpdLocation != nil {
ok := object.Key("MpdLocation")
ok.String(*v.MpdLocation)
}
if len(v.OriginManifestType) > 0 {
ok := object.Key("OriginManifestType")
ok.String(string(v.OriginManifestType))
}
return nil
}
func awsRestjson1_serializeDocumentDashPlaylistSettings(v *types.DashPlaylistSettings, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ManifestWindowSeconds != 0 {
ok := object.Key("ManifestWindowSeconds")
ok.Integer(v.ManifestWindowSeconds)
}
if v.MinBufferTimeSeconds != 0 {
ok := object.Key("MinBufferTimeSeconds")
ok.Integer(v.MinBufferTimeSeconds)
}
if v.MinUpdatePeriodSeconds != 0 {
ok := object.Key("MinUpdatePeriodSeconds")
ok.Integer(v.MinUpdatePeriodSeconds)
}
if v.SuggestedPresentationDelaySeconds != 0 {
ok := object.Key("SuggestedPresentationDelaySeconds")
ok.Integer(v.SuggestedPresentationDelaySeconds)
}
return nil
}
func awsRestjson1_serializeDocumentDefaultSegmentDeliveryConfiguration(v *types.DefaultSegmentDeliveryConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.BaseUrl != nil {
ok := object.Key("BaseUrl")
ok.String(*v.BaseUrl)
}
return nil
}
func awsRestjson1_serializeDocumentHlsPlaylistSettings(v *types.HlsPlaylistSettings, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ManifestWindowSeconds != 0 {
ok := object.Key("ManifestWindowSeconds")
ok.Integer(v.ManifestWindowSeconds)
}
return nil
}
func awsRestjson1_serializeDocumentHttpConfiguration(v *types.HttpConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.BaseUrl != nil {
ok := object.Key("BaseUrl")
ok.String(*v.BaseUrl)
}
return nil
}
func awsRestjson1_serializeDocumentHttpPackageConfiguration(v *types.HttpPackageConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Path != nil {
ok := object.Key("Path")
ok.String(*v.Path)
}
if v.SourceGroup != nil {
ok := object.Key("SourceGroup")
ok.String(*v.SourceGroup)
}
if len(v.Type) > 0 {
ok := object.Key("Type")
ok.String(string(v.Type))
}
return nil
}
func awsRestjson1_serializeDocumentHttpPackageConfigurations(v []types.HttpPackageConfiguration, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentHttpPackageConfiguration(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentLivePreRollConfiguration(v *types.LivePreRollConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AdDecisionServerUrl != nil {
ok := object.Key("AdDecisionServerUrl")
ok.String(*v.AdDecisionServerUrl)
}
if v.MaxDurationSeconds != 0 {
ok := object.Key("MaxDurationSeconds")
ok.Integer(v.MaxDurationSeconds)
}
return nil
}
func awsRestjson1_serializeDocumentLogTypes(v []types.LogType, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(string(v[i]))
}
return nil
}
func awsRestjson1_serializeDocumentManifestProcessingRules(v *types.ManifestProcessingRules, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AdMarkerPassthrough != nil {
ok := object.Key("AdMarkerPassthrough")
if err := awsRestjson1_serializeDocumentAdMarkerPassthrough(v.AdMarkerPassthrough, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentPrefetchConsumption(v *types.PrefetchConsumption, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AvailMatchingCriteria != nil {
ok := object.Key("AvailMatchingCriteria")
if err := awsRestjson1_serializeDocument__listOfAvailMatchingCriteria(v.AvailMatchingCriteria, ok); err != nil {
return err
}
}
if v.EndTime != nil {
ok := object.Key("EndTime")
ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
}
if v.StartTime != nil {
ok := object.Key("StartTime")
ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
}
return nil
}
func awsRestjson1_serializeDocumentPrefetchRetrieval(v *types.PrefetchRetrieval, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DynamicVariables != nil {
ok := object.Key("DynamicVariables")
if err := awsRestjson1_serializeDocument__mapOf__string(v.DynamicVariables, ok); err != nil {
return err
}
}
if v.EndTime != nil {
ok := object.Key("EndTime")
ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
}
if v.StartTime != nil {
ok := object.Key("StartTime")
ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
}
return nil
}
func awsRestjson1_serializeDocumentRequestOutputItem(v *types.RequestOutputItem, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DashPlaylistSettings != nil {
ok := object.Key("DashPlaylistSettings")
if err := awsRestjson1_serializeDocumentDashPlaylistSettings(v.DashPlaylistSettings, ok); err != nil {
return err
}
}
if v.HlsPlaylistSettings != nil {
ok := object.Key("HlsPlaylistSettings")
if err := awsRestjson1_serializeDocumentHlsPlaylistSettings(v.HlsPlaylistSettings, ok); err != nil {
return err
}
}
if v.ManifestName != nil {
ok := object.Key("ManifestName")
ok.String(*v.ManifestName)
}
if v.SourceGroup != nil {
ok := object.Key("SourceGroup")
ok.String(*v.SourceGroup)
}
return nil
}
func awsRestjson1_serializeDocumentRequestOutputs(v []types.RequestOutputItem, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentRequestOutputItem(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentScheduleConfiguration(v *types.ScheduleConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClipRange != nil {
ok := object.Key("ClipRange")
if err := awsRestjson1_serializeDocumentClipRange(v.ClipRange, ok); err != nil {
return err
}
}
if v.Transition != nil {
ok := object.Key("Transition")
if err := awsRestjson1_serializeDocumentTransition(v.Transition, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentSecretsManagerAccessTokenConfiguration(v *types.SecretsManagerAccessTokenConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.HeaderName != nil {
ok := object.Key("HeaderName")
ok.String(*v.HeaderName)
}
if v.SecretArn != nil {
ok := object.Key("SecretArn")
ok.String(*v.SecretArn)
}
if v.SecretStringKey != nil {
ok := object.Key("SecretStringKey")
ok.String(*v.SecretStringKey)
}
return nil
}
func awsRestjson1_serializeDocumentSegmentationDescriptor(v *types.SegmentationDescriptor, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.SegmentationEventId != nil {
ok := object.Key("SegmentationEventId")
ok.Integer(*v.SegmentationEventId)
}
if v.SegmentationTypeId != nil {
ok := object.Key("SegmentationTypeId")
ok.Integer(*v.SegmentationTypeId)
}
if v.SegmentationUpid != nil {
ok := object.Key("SegmentationUpid")
ok.String(*v.SegmentationUpid)
}
if v.SegmentationUpidType != nil {
ok := object.Key("SegmentationUpidType")
ok.Integer(*v.SegmentationUpidType)
}
if v.SegmentNum != nil {
ok := object.Key("SegmentNum")
ok.Integer(*v.SegmentNum)
}
if v.SegmentsExpected != nil {
ok := object.Key("SegmentsExpected")
ok.Integer(*v.SegmentsExpected)
}
if v.SubSegmentNum != nil {
ok := object.Key("SubSegmentNum")
ok.Integer(*v.SubSegmentNum)
}
if v.SubSegmentsExpected != nil {
ok := object.Key("SubSegmentsExpected")
ok.Integer(*v.SubSegmentsExpected)
}
return nil
}
func awsRestjson1_serializeDocumentSegmentationDescriptorList(v []types.SegmentationDescriptor, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentSegmentationDescriptor(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentSegmentDeliveryConfiguration(v *types.SegmentDeliveryConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.BaseUrl != nil {
ok := object.Key("BaseUrl")
ok.String(*v.BaseUrl)
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
return nil
}
func awsRestjson1_serializeDocumentSlateSource(v *types.SlateSource, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.SourceLocationName != nil {
ok := object.Key("SourceLocationName")
ok.String(*v.SourceLocationName)
}
if v.VodSourceName != nil {
ok := object.Key("VodSourceName")
ok.String(*v.VodSourceName)
}
return nil
}
func awsRestjson1_serializeDocumentSpliceInsertMessage(v *types.SpliceInsertMessage, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AvailNum != 0 {
ok := object.Key("AvailNum")
ok.Integer(v.AvailNum)
}
if v.AvailsExpected != 0 {
ok := object.Key("AvailsExpected")
ok.Integer(v.AvailsExpected)
}
if v.SpliceEventId != 0 {
ok := object.Key("SpliceEventId")
ok.Integer(v.SpliceEventId)
}
if v.UniqueProgramId != 0 {
ok := object.Key("UniqueProgramId")
ok.Integer(v.UniqueProgramId)
}
return nil
}
func awsRestjson1_serializeDocumentTimeSignalMessage(v *types.TimeSignalMessage, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.SegmentationDescriptors != nil {
ok := object.Key("SegmentationDescriptors")
if err := awsRestjson1_serializeDocumentSegmentationDescriptorList(v.SegmentationDescriptors, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentTransition(v *types.Transition, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DurationMillis != 0 {
ok := object.Key("DurationMillis")
ok.Long(v.DurationMillis)
}
if len(v.RelativePosition) > 0 {
ok := object.Key("RelativePosition")
ok.String(string(v.RelativePosition))
}
if v.RelativeProgram != nil {
ok := object.Key("RelativeProgram")
ok.String(*v.RelativeProgram)
}
if v.ScheduledStartTimeMillis != 0 {
ok := object.Key("ScheduledStartTimeMillis")
ok.Long(v.ScheduledStartTimeMillis)
}
if v.Type != nil {
ok := object.Key("Type")
ok.String(*v.Type)
}
return nil
}
func awsRestjson1_serializeDocumentUpdateProgramScheduleConfiguration(v *types.UpdateProgramScheduleConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClipRange != nil {
ok := object.Key("ClipRange")
if err := awsRestjson1_serializeDocumentClipRange(v.ClipRange, ok); err != nil {
return err
}
}
if v.Transition != nil {
ok := object.Key("Transition")
if err := awsRestjson1_serializeDocumentUpdateProgramTransition(v.Transition, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentUpdateProgramTransition(v *types.UpdateProgramTransition, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DurationMillis != 0 {
ok := object.Key("DurationMillis")
ok.Long(v.DurationMillis)
}
if v.ScheduledStartTimeMillis != 0 {
ok := object.Key("ScheduledStartTimeMillis")
ok.Long(v.ScheduledStartTimeMillis)
}
return nil
}
| 4,069 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mediatailor
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/mediatailor/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpConfigureLogsForChannel struct {
}
func (*validateOpConfigureLogsForChannel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpConfigureLogsForChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ConfigureLogsForChannelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpConfigureLogsForChannelInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpConfigureLogsForPlaybackConfiguration struct {
}
func (*validateOpConfigureLogsForPlaybackConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpConfigureLogsForPlaybackConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ConfigureLogsForPlaybackConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpConfigureLogsForPlaybackConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateChannel struct {
}
func (*validateOpCreateChannel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateChannelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateChannelInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateLiveSource struct {
}
func (*validateOpCreateLiveSource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateLiveSource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateLiveSourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateLiveSourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreatePrefetchSchedule struct {
}
func (*validateOpCreatePrefetchSchedule) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreatePrefetchSchedule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreatePrefetchScheduleInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreatePrefetchScheduleInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateProgram struct {
}
func (*validateOpCreateProgram) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateProgram) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateProgramInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateProgramInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateSourceLocation struct {
}
func (*validateOpCreateSourceLocation) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateSourceLocation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateSourceLocationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateSourceLocationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateVodSource struct {
}
func (*validateOpCreateVodSource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateVodSource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateVodSourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateVodSourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteChannel struct {
}
func (*validateOpDeleteChannel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteChannelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteChannelInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteChannelPolicy struct {
}
func (*validateOpDeleteChannelPolicy) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteChannelPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteChannelPolicyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteChannelPolicyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteLiveSource struct {
}
func (*validateOpDeleteLiveSource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteLiveSource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteLiveSourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteLiveSourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeletePlaybackConfiguration struct {
}
func (*validateOpDeletePlaybackConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeletePlaybackConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeletePlaybackConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeletePlaybackConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeletePrefetchSchedule struct {
}
func (*validateOpDeletePrefetchSchedule) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeletePrefetchSchedule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeletePrefetchScheduleInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeletePrefetchScheduleInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteProgram struct {
}
func (*validateOpDeleteProgram) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteProgram) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteProgramInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteProgramInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteSourceLocation struct {
}
func (*validateOpDeleteSourceLocation) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteSourceLocation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteSourceLocationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteSourceLocationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteVodSource struct {
}
func (*validateOpDeleteVodSource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteVodSource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteVodSourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteVodSourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeChannel struct {
}
func (*validateOpDescribeChannel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeChannelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeChannelInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeLiveSource struct {
}
func (*validateOpDescribeLiveSource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeLiveSource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeLiveSourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeLiveSourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeProgram struct {
}
func (*validateOpDescribeProgram) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeProgram) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeProgramInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeProgramInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeSourceLocation struct {
}
func (*validateOpDescribeSourceLocation) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeSourceLocation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeSourceLocationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeSourceLocationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeVodSource struct {
}
func (*validateOpDescribeVodSource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeVodSource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeVodSourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeVodSourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetChannelPolicy struct {
}
func (*validateOpGetChannelPolicy) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetChannelPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetChannelPolicyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetChannelPolicyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetChannelSchedule struct {
}
func (*validateOpGetChannelSchedule) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetChannelSchedule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetChannelScheduleInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetChannelScheduleInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetPlaybackConfiguration struct {
}
func (*validateOpGetPlaybackConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetPlaybackConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetPlaybackConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetPlaybackConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetPrefetchSchedule struct {
}
func (*validateOpGetPrefetchSchedule) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetPrefetchSchedule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetPrefetchScheduleInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetPrefetchScheduleInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListAlerts struct {
}
func (*validateOpListAlerts) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListAlerts) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListAlertsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListAlertsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListLiveSources struct {
}
func (*validateOpListLiveSources) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListLiveSources) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListLiveSourcesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListLiveSourcesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListPrefetchSchedules struct {
}
func (*validateOpListPrefetchSchedules) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListPrefetchSchedules) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListPrefetchSchedulesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListPrefetchSchedulesInput(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 validateOpListVodSources struct {
}
func (*validateOpListVodSources) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListVodSources) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListVodSourcesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListVodSourcesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpPutChannelPolicy struct {
}
func (*validateOpPutChannelPolicy) ID() string {
return "OperationInputValidation"
}
func (m *validateOpPutChannelPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*PutChannelPolicyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpPutChannelPolicyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpPutPlaybackConfiguration struct {
}
func (*validateOpPutPlaybackConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpPutPlaybackConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*PutPlaybackConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpPutPlaybackConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartChannel struct {
}
func (*validateOpStartChannel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartChannelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartChannelInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStopChannel struct {
}
func (*validateOpStopChannel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStopChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StopChannelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStopChannelInput(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 validateOpUpdateChannel struct {
}
func (*validateOpUpdateChannel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateChannelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateChannelInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateLiveSource struct {
}
func (*validateOpUpdateLiveSource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateLiveSource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateLiveSourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateLiveSourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateProgram struct {
}
func (*validateOpUpdateProgram) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateProgram) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateProgramInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateProgramInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateSourceLocation struct {
}
func (*validateOpUpdateSourceLocation) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateSourceLocation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateSourceLocationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateSourceLocationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateVodSource struct {
}
func (*validateOpUpdateVodSource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateVodSource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateVodSourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateVodSourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpConfigureLogsForChannelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpConfigureLogsForChannel{}, middleware.After)
}
func addOpConfigureLogsForPlaybackConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpConfigureLogsForPlaybackConfiguration{}, middleware.After)
}
func addOpCreateChannelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateChannel{}, middleware.After)
}
func addOpCreateLiveSourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateLiveSource{}, middleware.After)
}
func addOpCreatePrefetchScheduleValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreatePrefetchSchedule{}, middleware.After)
}
func addOpCreateProgramValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateProgram{}, middleware.After)
}
func addOpCreateSourceLocationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateSourceLocation{}, middleware.After)
}
func addOpCreateVodSourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateVodSource{}, middleware.After)
}
func addOpDeleteChannelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteChannel{}, middleware.After)
}
func addOpDeleteChannelPolicyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteChannelPolicy{}, middleware.After)
}
func addOpDeleteLiveSourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteLiveSource{}, middleware.After)
}
func addOpDeletePlaybackConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeletePlaybackConfiguration{}, middleware.After)
}
func addOpDeletePrefetchScheduleValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeletePrefetchSchedule{}, middleware.After)
}
func addOpDeleteProgramValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteProgram{}, middleware.After)
}
func addOpDeleteSourceLocationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteSourceLocation{}, middleware.After)
}
func addOpDeleteVodSourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteVodSource{}, middleware.After)
}
func addOpDescribeChannelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeChannel{}, middleware.After)
}
func addOpDescribeLiveSourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeLiveSource{}, middleware.After)
}
func addOpDescribeProgramValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeProgram{}, middleware.After)
}
func addOpDescribeSourceLocationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeSourceLocation{}, middleware.After)
}
func addOpDescribeVodSourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeVodSource{}, middleware.After)
}
func addOpGetChannelPolicyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetChannelPolicy{}, middleware.After)
}
func addOpGetChannelScheduleValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetChannelSchedule{}, middleware.After)
}
func addOpGetPlaybackConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetPlaybackConfiguration{}, middleware.After)
}
func addOpGetPrefetchScheduleValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetPrefetchSchedule{}, middleware.After)
}
func addOpListAlertsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListAlerts{}, middleware.After)
}
func addOpListLiveSourcesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListLiveSources{}, middleware.After)
}
func addOpListPrefetchSchedulesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListPrefetchSchedules{}, middleware.After)
}
func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
}
func addOpListVodSourcesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListVodSources{}, middleware.After)
}
func addOpPutChannelPolicyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpPutChannelPolicy{}, middleware.After)
}
func addOpPutPlaybackConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpPutPlaybackConfiguration{}, middleware.After)
}
func addOpStartChannelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartChannel{}, middleware.After)
}
func addOpStopChannelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStopChannel{}, 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 addOpUpdateChannelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateChannel{}, middleware.After)
}
func addOpUpdateLiveSourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateLiveSource{}, middleware.After)
}
func addOpUpdateProgramValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateProgram{}, middleware.After)
}
func addOpUpdateSourceLocationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateSourceLocation{}, middleware.After)
}
func addOpUpdateVodSourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateVodSource{}, middleware.After)
}
func validate__listOfAvailMatchingCriteria(v []types.AvailMatchingCriteria) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListOfAvailMatchingCriteria"}
for i := range v {
if err := validateAvailMatchingCriteria(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAvailMatchingCriteria(v *types.AvailMatchingCriteria) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AvailMatchingCriteria"}
if v.DynamicVariable == nil {
invalidParams.Add(smithy.NewErrParamRequired("DynamicVariable"))
}
if len(v.Operator) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Operator"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateClipRange(v *types.ClipRange) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ClipRange"}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateHttpConfiguration(v *types.HttpConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "HttpConfiguration"}
if v.BaseUrl == nil {
invalidParams.Add(smithy.NewErrParamRequired("BaseUrl"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateHttpPackageConfiguration(v *types.HttpPackageConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "HttpPackageConfiguration"}
if v.Path == nil {
invalidParams.Add(smithy.NewErrParamRequired("Path"))
}
if v.SourceGroup == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceGroup"))
}
if len(v.Type) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Type"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateHttpPackageConfigurations(v []types.HttpPackageConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "HttpPackageConfigurations"}
for i := range v {
if err := validateHttpPackageConfiguration(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validatePrefetchConsumption(v *types.PrefetchConsumption) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PrefetchConsumption"}
if v.AvailMatchingCriteria != nil {
if err := validate__listOfAvailMatchingCriteria(v.AvailMatchingCriteria); err != nil {
invalidParams.AddNested("AvailMatchingCriteria", err.(smithy.InvalidParamsError))
}
}
if v.EndTime == nil {
invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validatePrefetchRetrieval(v *types.PrefetchRetrieval) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PrefetchRetrieval"}
if v.EndTime == nil {
invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateRequestOutputItem(v *types.RequestOutputItem) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RequestOutputItem"}
if v.ManifestName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ManifestName"))
}
if v.SourceGroup == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceGroup"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateRequestOutputs(v []types.RequestOutputItem) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RequestOutputs"}
for i := range v {
if err := validateRequestOutputItem(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateScheduleConfiguration(v *types.ScheduleConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ScheduleConfiguration"}
if v.Transition == nil {
invalidParams.Add(smithy.NewErrParamRequired("Transition"))
} else if v.Transition != nil {
if err := validateTransition(v.Transition); err != nil {
invalidParams.AddNested("Transition", err.(smithy.InvalidParamsError))
}
}
if v.ClipRange != nil {
if err := validateClipRange(v.ClipRange); err != nil {
invalidParams.AddNested("ClipRange", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTransition(v *types.Transition) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Transition"}
if len(v.RelativePosition) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("RelativePosition"))
}
if v.Type == nil {
invalidParams.Add(smithy.NewErrParamRequired("Type"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateUpdateProgramScheduleConfiguration(v *types.UpdateProgramScheduleConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateProgramScheduleConfiguration"}
if v.ClipRange != nil {
if err := validateClipRange(v.ClipRange); err != nil {
invalidParams.AddNested("ClipRange", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpConfigureLogsForChannelInput(v *ConfigureLogsForChannelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ConfigureLogsForChannelInput"}
if v.ChannelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
}
if v.LogTypes == nil {
invalidParams.Add(smithy.NewErrParamRequired("LogTypes"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpConfigureLogsForPlaybackConfigurationInput(v *ConfigureLogsForPlaybackConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ConfigureLogsForPlaybackConfigurationInput"}
if v.PlaybackConfigurationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("PlaybackConfigurationName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateChannelInput(v *CreateChannelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateChannelInput"}
if v.ChannelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
}
if v.Outputs == nil {
invalidParams.Add(smithy.NewErrParamRequired("Outputs"))
} else if v.Outputs != nil {
if err := validateRequestOutputs(v.Outputs); err != nil {
invalidParams.AddNested("Outputs", err.(smithy.InvalidParamsError))
}
}
if len(v.PlaybackMode) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("PlaybackMode"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateLiveSourceInput(v *CreateLiveSourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateLiveSourceInput"}
if v.HttpPackageConfigurations == nil {
invalidParams.Add(smithy.NewErrParamRequired("HttpPackageConfigurations"))
} else if v.HttpPackageConfigurations != nil {
if err := validateHttpPackageConfigurations(v.HttpPackageConfigurations); err != nil {
invalidParams.AddNested("HttpPackageConfigurations", err.(smithy.InvalidParamsError))
}
}
if v.LiveSourceName == nil {
invalidParams.Add(smithy.NewErrParamRequired("LiveSourceName"))
}
if v.SourceLocationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreatePrefetchScheduleInput(v *CreatePrefetchScheduleInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreatePrefetchScheduleInput"}
if v.Consumption == nil {
invalidParams.Add(smithy.NewErrParamRequired("Consumption"))
} else if v.Consumption != nil {
if err := validatePrefetchConsumption(v.Consumption); err != nil {
invalidParams.AddNested("Consumption", err.(smithy.InvalidParamsError))
}
}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.PlaybackConfigurationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("PlaybackConfigurationName"))
}
if v.Retrieval == nil {
invalidParams.Add(smithy.NewErrParamRequired("Retrieval"))
} else if v.Retrieval != nil {
if err := validatePrefetchRetrieval(v.Retrieval); err != nil {
invalidParams.AddNested("Retrieval", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateProgramInput(v *CreateProgramInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateProgramInput"}
if v.ChannelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
}
if v.ProgramName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ProgramName"))
}
if v.ScheduleConfiguration == nil {
invalidParams.Add(smithy.NewErrParamRequired("ScheduleConfiguration"))
} else if v.ScheduleConfiguration != nil {
if err := validateScheduleConfiguration(v.ScheduleConfiguration); err != nil {
invalidParams.AddNested("ScheduleConfiguration", err.(smithy.InvalidParamsError))
}
}
if v.SourceLocationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateSourceLocationInput(v *CreateSourceLocationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateSourceLocationInput"}
if v.HttpConfiguration == nil {
invalidParams.Add(smithy.NewErrParamRequired("HttpConfiguration"))
} else if v.HttpConfiguration != nil {
if err := validateHttpConfiguration(v.HttpConfiguration); err != nil {
invalidParams.AddNested("HttpConfiguration", err.(smithy.InvalidParamsError))
}
}
if v.SourceLocationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateVodSourceInput(v *CreateVodSourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateVodSourceInput"}
if v.HttpPackageConfigurations == nil {
invalidParams.Add(smithy.NewErrParamRequired("HttpPackageConfigurations"))
} else if v.HttpPackageConfigurations != nil {
if err := validateHttpPackageConfigurations(v.HttpPackageConfigurations); err != nil {
invalidParams.AddNested("HttpPackageConfigurations", err.(smithy.InvalidParamsError))
}
}
if v.SourceLocationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
}
if v.VodSourceName == nil {
invalidParams.Add(smithy.NewErrParamRequired("VodSourceName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteChannelInput(v *DeleteChannelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteChannelInput"}
if v.ChannelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteChannelPolicyInput(v *DeleteChannelPolicyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteChannelPolicyInput"}
if v.ChannelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteLiveSourceInput(v *DeleteLiveSourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteLiveSourceInput"}
if v.LiveSourceName == nil {
invalidParams.Add(smithy.NewErrParamRequired("LiveSourceName"))
}
if v.SourceLocationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeletePlaybackConfigurationInput(v *DeletePlaybackConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeletePlaybackConfigurationInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeletePrefetchScheduleInput(v *DeletePrefetchScheduleInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeletePrefetchScheduleInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.PlaybackConfigurationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("PlaybackConfigurationName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteProgramInput(v *DeleteProgramInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteProgramInput"}
if v.ChannelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
}
if v.ProgramName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ProgramName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteSourceLocationInput(v *DeleteSourceLocationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteSourceLocationInput"}
if v.SourceLocationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteVodSourceInput(v *DeleteVodSourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteVodSourceInput"}
if v.SourceLocationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
}
if v.VodSourceName == nil {
invalidParams.Add(smithy.NewErrParamRequired("VodSourceName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeChannelInput(v *DescribeChannelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeChannelInput"}
if v.ChannelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeLiveSourceInput(v *DescribeLiveSourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeLiveSourceInput"}
if v.LiveSourceName == nil {
invalidParams.Add(smithy.NewErrParamRequired("LiveSourceName"))
}
if v.SourceLocationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeProgramInput(v *DescribeProgramInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeProgramInput"}
if v.ChannelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
}
if v.ProgramName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ProgramName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeSourceLocationInput(v *DescribeSourceLocationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeSourceLocationInput"}
if v.SourceLocationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeVodSourceInput(v *DescribeVodSourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeVodSourceInput"}
if v.SourceLocationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
}
if v.VodSourceName == nil {
invalidParams.Add(smithy.NewErrParamRequired("VodSourceName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetChannelPolicyInput(v *GetChannelPolicyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetChannelPolicyInput"}
if v.ChannelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetChannelScheduleInput(v *GetChannelScheduleInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetChannelScheduleInput"}
if v.ChannelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetPlaybackConfigurationInput(v *GetPlaybackConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetPlaybackConfigurationInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetPrefetchScheduleInput(v *GetPrefetchScheduleInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetPrefetchScheduleInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.PlaybackConfigurationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("PlaybackConfigurationName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListAlertsInput(v *ListAlertsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListAlertsInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListLiveSourcesInput(v *ListLiveSourcesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListLiveSourcesInput"}
if v.SourceLocationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListPrefetchSchedulesInput(v *ListPrefetchSchedulesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListPrefetchSchedulesInput"}
if v.PlaybackConfigurationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("PlaybackConfigurationName"))
}
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 validateOpListVodSourcesInput(v *ListVodSourcesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListVodSourcesInput"}
if v.SourceLocationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpPutChannelPolicyInput(v *PutChannelPolicyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PutChannelPolicyInput"}
if v.ChannelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
}
if v.Policy == nil {
invalidParams.Add(smithy.NewErrParamRequired("Policy"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpPutPlaybackConfigurationInput(v *PutPlaybackConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PutPlaybackConfigurationInput"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartChannelInput(v *StartChannelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartChannelInput"}
if v.ChannelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStopChannelInput(v *StopChannelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StopChannelInput"}
if v.ChannelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
}
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 validateOpUpdateChannelInput(v *UpdateChannelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateChannelInput"}
if v.ChannelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
}
if v.Outputs == nil {
invalidParams.Add(smithy.NewErrParamRequired("Outputs"))
} else if v.Outputs != nil {
if err := validateRequestOutputs(v.Outputs); err != nil {
invalidParams.AddNested("Outputs", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateLiveSourceInput(v *UpdateLiveSourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateLiveSourceInput"}
if v.HttpPackageConfigurations == nil {
invalidParams.Add(smithy.NewErrParamRequired("HttpPackageConfigurations"))
} else if v.HttpPackageConfigurations != nil {
if err := validateHttpPackageConfigurations(v.HttpPackageConfigurations); err != nil {
invalidParams.AddNested("HttpPackageConfigurations", err.(smithy.InvalidParamsError))
}
}
if v.LiveSourceName == nil {
invalidParams.Add(smithy.NewErrParamRequired("LiveSourceName"))
}
if v.SourceLocationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateProgramInput(v *UpdateProgramInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateProgramInput"}
if v.ChannelName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
}
if v.ProgramName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ProgramName"))
}
if v.ScheduleConfiguration == nil {
invalidParams.Add(smithy.NewErrParamRequired("ScheduleConfiguration"))
} else if v.ScheduleConfiguration != nil {
if err := validateUpdateProgramScheduleConfiguration(v.ScheduleConfiguration); err != nil {
invalidParams.AddNested("ScheduleConfiguration", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateSourceLocationInput(v *UpdateSourceLocationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateSourceLocationInput"}
if v.HttpConfiguration == nil {
invalidParams.Add(smithy.NewErrParamRequired("HttpConfiguration"))
} else if v.HttpConfiguration != nil {
if err := validateHttpConfiguration(v.HttpConfiguration); err != nil {
invalidParams.AddNested("HttpConfiguration", err.(smithy.InvalidParamsError))
}
}
if v.SourceLocationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateVodSourceInput(v *UpdateVodSourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateVodSourceInput"}
if v.HttpPackageConfigurations == nil {
invalidParams.Add(smithy.NewErrParamRequired("HttpPackageConfigurations"))
} else if v.HttpPackageConfigurations != nil {
if err := validateHttpPackageConfigurations(v.HttpPackageConfigurations); err != nil {
invalidParams.AddNested("HttpPackageConfigurations", err.(smithy.InvalidParamsError))
}
}
if v.SourceLocationName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceLocationName"))
}
if v.VodSourceName == nil {
invalidParams.Add(smithy.NewErrParamRequired("VodSourceName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 1,987 |
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 MediaTailor 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.mediatailor.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "api.mediatailor-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "api.mediatailor-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.mediatailor.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.Aws,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "af-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-northeast-1",
}: 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: "eu-central-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-east-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-west-2",
}: endpoints.Endpoint{},
},
},
{
ID: "aws-cn",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "api.mediatailor.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "api.mediatailor-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "api.mediatailor-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.mediatailor.{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.mediatailor-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.mediatailor.{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.mediatailor-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.mediatailor.{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.mediatailor-fips.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.mediatailor.{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.mediatailor-fips.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.mediatailor.{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.mediatailor.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "api.mediatailor-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "api.mediatailor-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "api.mediatailor.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: true,
},
}
| 329 |
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 AccessType string
// Enum values for AccessType
const (
AccessTypeS3Sigv4 AccessType = "S3_SIGV4"
AccessTypeSecretsManagerAccessToken AccessType = "SECRETS_MANAGER_ACCESS_TOKEN"
)
// Values returns all known values for AccessType. 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 (AccessType) Values() []AccessType {
return []AccessType{
"S3_SIGV4",
"SECRETS_MANAGER_ACCESS_TOKEN",
}
}
type ChannelState string
// Enum values for ChannelState
const (
ChannelStateRunning ChannelState = "RUNNING"
ChannelStateStopped ChannelState = "STOPPED"
)
// Values returns all known values for ChannelState. 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 (ChannelState) Values() []ChannelState {
return []ChannelState{
"RUNNING",
"STOPPED",
}
}
type FillPolicy string
// Enum values for FillPolicy
const (
FillPolicyFullAvailOnly FillPolicy = "FULL_AVAIL_ONLY"
FillPolicyPartialAvail FillPolicy = "PARTIAL_AVAIL"
)
// Values returns all known values for FillPolicy. 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 (FillPolicy) Values() []FillPolicy {
return []FillPolicy{
"FULL_AVAIL_ONLY",
"PARTIAL_AVAIL",
}
}
type LogType string
// Enum values for LogType
const (
LogTypeAsRun LogType = "AS_RUN"
)
// Values returns all known values for LogType. 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 (LogType) Values() []LogType {
return []LogType{
"AS_RUN",
}
}
type MessageType string
// Enum values for MessageType
const (
MessageTypeSpliceInsert MessageType = "SPLICE_INSERT"
MessageTypeTimeSignal MessageType = "TIME_SIGNAL"
)
// Values returns all known values for MessageType. 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 (MessageType) Values() []MessageType {
return []MessageType{
"SPLICE_INSERT",
"TIME_SIGNAL",
}
}
type Mode string
// Enum values for Mode
const (
ModeOff Mode = "OFF"
ModeBehindLiveEdge Mode = "BEHIND_LIVE_EDGE"
ModeAfterLiveEdge Mode = "AFTER_LIVE_EDGE"
)
// Values returns all known values for Mode. 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 (Mode) Values() []Mode {
return []Mode{
"OFF",
"BEHIND_LIVE_EDGE",
"AFTER_LIVE_EDGE",
}
}
type Operator string
// Enum values for Operator
const (
OperatorEquals Operator = "EQUALS"
)
// Values returns all known values for Operator. 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 (Operator) Values() []Operator {
return []Operator{
"EQUALS",
}
}
type OriginManifestType string
// Enum values for OriginManifestType
const (
OriginManifestTypeSinglePeriod OriginManifestType = "SINGLE_PERIOD"
OriginManifestTypeMultiPeriod OriginManifestType = "MULTI_PERIOD"
)
// Values returns all known values for OriginManifestType. 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 (OriginManifestType) Values() []OriginManifestType {
return []OriginManifestType{
"SINGLE_PERIOD",
"MULTI_PERIOD",
}
}
type PlaybackMode string
// Enum values for PlaybackMode
const (
PlaybackModeLoop PlaybackMode = "LOOP"
PlaybackModeLinear PlaybackMode = "LINEAR"
)
// Values returns all known values for PlaybackMode. 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 (PlaybackMode) Values() []PlaybackMode {
return []PlaybackMode{
"LOOP",
"LINEAR",
}
}
type RelativePosition string
// Enum values for RelativePosition
const (
RelativePositionBeforeProgram RelativePosition = "BEFORE_PROGRAM"
RelativePositionAfterProgram RelativePosition = "AFTER_PROGRAM"
)
// Values returns all known values for RelativePosition. 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 (RelativePosition) Values() []RelativePosition {
return []RelativePosition{
"BEFORE_PROGRAM",
"AFTER_PROGRAM",
}
}
type ScheduleEntryType string
// Enum values for ScheduleEntryType
const (
ScheduleEntryTypeProgram ScheduleEntryType = "PROGRAM"
ScheduleEntryTypeFillerSlate ScheduleEntryType = "FILLER_SLATE"
)
// Values returns all known values for ScheduleEntryType. 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 (ScheduleEntryType) Values() []ScheduleEntryType {
return []ScheduleEntryType{
"PROGRAM",
"FILLER_SLATE",
}
}
type Tier string
// Enum values for Tier
const (
TierBasic Tier = "BASIC"
TierStandard Tier = "STANDARD"
)
// Values returns all known values for Tier. 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 (Tier) Values() []Tier {
return []Tier{
"BASIC",
"STANDARD",
}
}
type Type string
// Enum values for Type
const (
TypeDash Type = "DASH"
TypeHls Type = "HLS"
)
// Values returns all known values for Type. 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 (Type) Values() []Type {
return []Type{
"DASH",
"HLS",
}
}
| 236 |
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"
)
// A request contains unexpected data.
type BadRequestException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *BadRequestException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *BadRequestException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *BadRequestException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "BadRequestException"
}
return *e.ErrorCodeOverride
}
func (e *BadRequestException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
| 35 |
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"
)
// Access configuration parameters.
type AccessConfiguration struct {
// The type of authentication used to access content from
// HttpConfiguration::BaseUrl on your source location. Accepted value: S3_SIGV4 .
// S3_SIGV4 - AWS Signature Version 4 authentication for Amazon S3 hosted
// virtual-style access. If your source location base URL is an Amazon S3 bucket,
// MediaTailor can use AWS Signature Version 4 (SigV4) authentication to access the
// bucket where your source content is stored. Your MediaTailor source location
// baseURL must follow the S3 virtual hosted-style request URL format. For example,
// https://bucket-name.s3.Region.amazonaws.com/key-name. Before you can use
// S3_SIGV4 , you must meet these requirements: • You must allow MediaTailor to
// access your S3 bucket by granting mediatailor.amazonaws.com principal access in
// IAM. For information about configuring access in IAM, see Access management in
// the IAM User Guide. • The mediatailor.amazonaws.com service principal must have
// permissions to read all top level manifests referenced by the VodSource
// packaging configurations. • The caller of the API must have s3:GetObject IAM
// permissions to read all top level manifests referenced by your MediaTailor
// VodSource packaging configurations.
AccessType AccessType
// AWS Secrets Manager access token configuration parameters.
SecretsManagerAccessTokenConfiguration *SecretsManagerAccessTokenConfiguration
noSmithyDocumentSerde
}
// Ad break configuration parameters.
type AdBreak struct {
// The SCTE-35 ad insertion type. Accepted value: SPLICE_INSERT , TIME_SIGNAL .
MessageType MessageType
// How long (in milliseconds) after the beginning of the program that an ad
// starts. This value must fall within 100ms of a segment boundary, otherwise the
// ad break will be skipped.
OffsetMillis int64
// Ad break slate configuration.
Slate *SlateSource
// This defines the SCTE-35 splice_insert() message inserted around the ad. For
// information about using splice_insert() , see the SCTE-35 specficiaiton, section
// 9.7.3.1.
SpliceInsertMessage *SpliceInsertMessage
// Defines the SCTE-35 time_signal message inserted around the ad. Programs on a
// channel's schedule can be configured with one or more ad breaks. You can attach
// a splice_insert SCTE-35 message to the ad break. This message provides basic
// metadata about the ad break. See section 9.7.4 of the 2022 SCTE-35 specification
// for more information.
TimeSignalMessage *TimeSignalMessage
noSmithyDocumentSerde
}
// For HLS, when set to true , MediaTailor passes through EXT-X-CUE-IN ,
// EXT-X-CUE-OUT , and EXT-X-SPLICEPOINT-SCTE35 ad markers from the origin
// manifest to the MediaTailor personalized manifest. No logic is applied to these
// ad markers. For example, if EXT-X-CUE-OUT has a value of 60 , but no ads are
// filled for that ad break, MediaTailor will not set the value to 0 .
type AdMarkerPassthrough struct {
// Enables ad marker passthrough for your configuration.
Enabled bool
noSmithyDocumentSerde
}
// Alert configuration parameters.
type Alert struct {
// The code for the alert. For example, NOT_PROCESSED .
//
// This member is required.
AlertCode *string
// If an alert is generated for a resource, an explanation of the reason for the
// alert.
//
// This member is required.
AlertMessage *string
// The timestamp when the alert was last modified.
//
// This member is required.
LastModifiedTime *time.Time
// The Amazon Resource Names (ARNs) related to this alert.
//
// This member is required.
RelatedResourceArns []string
// The Amazon Resource Name (ARN) of the resource.
//
// This member is required.
ResourceArn *string
noSmithyDocumentSerde
}
// MediaTailor only places (consumes) prefetched ads if the ad break meets the
// criteria defined by the dynamic variables. This gives you granular control over
// which ad break to place the prefetched ads into. As an example, let's say that
// you set DynamicVariable to scte.event_id and Operator to EQUALS , and your
// playback configuration has an ADS URL of
// https://my.ads.server.com/path?&podId=[scte.avail_num]&event=[scte.event_id]&duration=[session.avail_duration_secs]
// . And the prefetch request to the ADS contains these values
// https://my.ads.server.com/path?&podId=3&event=my-awesome-event&duration=30 .
// MediaTailor will only insert the prefetched ads into the ad break if has a SCTE
// marker with an event id of my-awesome-event , since it must match the event id
// that MediaTailor uses to query the ADS. You can specify up to five
// AvailMatchingCriteria . If you specify multiple AvailMatchingCriteria ,
// MediaTailor combines them to match using a logical AND . You can model logical
// OR combinations by creating multiple prefetch schedules.
type AvailMatchingCriteria struct {
// The dynamic variable(s) that MediaTailor should use as avail matching criteria.
// MediaTailor only places the prefetched ads into the avail if the avail matches
// the criteria defined by the dynamic variable. For information about dynamic
// variables, see Using dynamic ad variables (https://docs.aws.amazon.com/mediatailor/latest/ug/variables.html)
// in the MediaTailor User Guide. You can include up to 100 dynamic variables.
//
// This member is required.
DynamicVariable *string
// For the DynamicVariable specified in AvailMatchingCriteria , the Operator that
// is used for the comparison.
//
// This member is required.
Operator Operator
noSmithyDocumentSerde
}
// The configuration for avail suppression, also known as ad suppression. For more
// information about ad suppression, see Ad Suppression (https://docs.aws.amazon.com/mediatailor/latest/ug/ad-behavior.html)
// .
type AvailSuppression struct {
// Defines the policy to apply to the avail suppression mode. BEHIND_LIVE_EDGE
// will always use the full avail suppression policy. AFTER_LIVE_EDGE mode can be
// used to invoke partial ad break fills when a session starts mid-break.
FillPolicy FillPolicy
// Sets the ad suppression mode. By default, ad suppression is off and all ad
// breaks are filled with ads or slate. When Mode is set to BEHIND_LIVE_EDGE , ad
// suppression is active and MediaTailor won't fill ad breaks on or behind the ad
// suppression Value time in the manifest lookback window. When Mode is set to
// AFTER_LIVE_EDGE , ad suppression is active and MediaTailor won't fill ad breaks
// that are within the live edge plus the avail suppression value.
Mode Mode
// A live edge offset time in HH:MM:SS. MediaTailor won't fill ad breaks on or
// behind this time in the manifest lookback window. If Value is set to 00:00:00,
// it is in sync with the live edge, and MediaTailor won't fill any ad breaks on or
// behind the live edge. If you set a Value time, MediaTailor won't fill any ad
// breaks on or behind this time in the manifest lookback window. For example, if
// you set 00:45:00, then MediaTailor will fill ad breaks that occur within 45
// minutes behind the live edge, but won't fill ad breaks on or behind 45 minutes
// behind the live edge.
Value *string
noSmithyDocumentSerde
}
// The configuration for bumpers. Bumpers are short audio or video clips that play
// at the start or before the end of an ad break. To learn more about bumpers, see
// Bumpers (https://docs.aws.amazon.com/mediatailor/latest/ug/bumpers.html) .
type Bumper struct {
// The URL for the end bumper asset.
EndUrl *string
// The URL for the start bumper asset.
StartUrl *string
noSmithyDocumentSerde
}
// The configuration for using a content delivery network (CDN), like Amazon
// CloudFront, for content and ad segment management.
type CdnConfiguration struct {
// A non-default content delivery network (CDN) to serve ad segments. By default,
// AWS Elemental MediaTailor uses Amazon CloudFront with default cache settings as
// its CDN for ad segments. To set up an alternate CDN, create a rule in your CDN
// for the origin ads.mediatailor.<region>.amazonaws.com. Then specify the rule's
// name in this AdSegmentUrlPrefix . When AWS Elemental MediaTailor serves a
// manifest, it reports your CDN as the source for ad segments.
AdSegmentUrlPrefix *string
// A content delivery network (CDN) to cache content segments, so that content
// requests don’t always have to go to the origin server. First, create a rule in
// your CDN for the content segment origin server. Then specify the rule's name in
// this ContentSegmentUrlPrefix . When AWS Elemental MediaTailor serves a manifest,
// it reports your CDN as the source for content segments.
ContentSegmentUrlPrefix *string
noSmithyDocumentSerde
}
// The configuration parameters for a channel. For information about MediaTailor
// channels, see Working with channels (https://docs.aws.amazon.com/mediatailor/latest/ug/channel-assembly-channels.html)
// in the MediaTailor User Guide.
type Channel struct {
// The ARN of the channel.
//
// This member is required.
Arn *string
// The name of the channel.
//
// This member is required.
ChannelName *string
// Returns the state whether the channel is running or not.
//
// This member is required.
ChannelState *string
// The log configuration.
//
// This member is required.
LogConfiguration *LogConfigurationForChannel
// The channel's output properties.
//
// This member is required.
Outputs []ResponseOutputItem
// The type of playback mode for this channel. LINEAR - Programs play back-to-back
// only once. LOOP - Programs play back-to-back in an endless loop. When the last
// program in the schedule plays, playback loops back to the first program in the
// schedule.
//
// This member is required.
PlaybackMode *string
// The tier for this channel. STANDARD tier channels can contain live programs.
//
// This member is required.
Tier *string
// The timestamp of when the channel was created.
CreationTime *time.Time
// The slate used to fill gaps between programs in the schedule. You must
// configure filler slate if your channel uses the LINEAR PlaybackMode .
// MediaTailor doesn't support filler slate for channels using the LOOP PlaybackMode
// .
FillerSlate *SlateSource
// The timestamp of when the channel was last modified.
LastModifiedTime *time.Time
// The tags to assign to the channel. Tags are key-value pairs that you can
// associate with Amazon resources to help with organization, access control, and
// cost tracking. For more information, see Tagging AWS Elemental MediaTailor
// Resources (https://docs.aws.amazon.com/mediatailor/latest/ug/tagging.html) .
Tags map[string]string
noSmithyDocumentSerde
}
// Clip range configuration for the VOD source associated with the program.
type ClipRange struct {
// The end offset of the clip range, in milliseconds, starting from the beginning
// of the VOD source associated with the program.
//
// This member is required.
EndOffsetMillis int64
noSmithyDocumentSerde
}
// The configuration for DASH content.
type DashConfiguration struct {
// The URL generated by MediaTailor to initiate a playback session. The session
// uses server-side reporting. This setting is ignored in PUT operations.
ManifestEndpointPrefix *string
// The setting that controls whether MediaTailor includes the Location tag in DASH
// manifests. MediaTailor populates the Location tag with the URL for manifest
// update requests, to be used by players that don't support sticky redirects.
// Disable this if you have CDN routing rules set up for accessing MediaTailor
// manifests, and you are either using client-side reporting or your players
// support sticky HTTP redirects. Valid values are DISABLED and EMT_DEFAULT . The
// EMT_DEFAULT setting enables the inclusion of the tag and is the default value.
MpdLocation *string
// The setting that controls whether MediaTailor handles manifests from the origin
// server as multi-period manifests or single-period manifests. If your origin
// server produces single-period manifests, set this to SINGLE_PERIOD . The default
// setting is MULTI_PERIOD . For multi-period manifests, omit this setting or set
// it to MULTI_PERIOD .
OriginManifestType OriginManifestType
noSmithyDocumentSerde
}
// The configuration for DASH PUT operations.
type DashConfigurationForPut struct {
// The setting that controls whether MediaTailor includes the Location tag in DASH
// manifests. MediaTailor populates the Location tag with the URL for manifest
// update requests, to be used by players that don't support sticky redirects.
// Disable this if you have CDN routing rules set up for accessing MediaTailor
// manifests, and you are either using client-side reporting or your players
// support sticky HTTP redirects. Valid values are DISABLED and EMT_DEFAULT . The
// EMT_DEFAULT setting enables the inclusion of the tag and is the default value.
MpdLocation *string
// The setting that controls whether MediaTailor handles manifests from the origin
// server as multi-period manifests or single-period manifests. If your origin
// server produces single-period manifests, set this to SINGLE_PERIOD . The default
// setting is MULTI_PERIOD . For multi-period manifests, omit this setting or set
// it to MULTI_PERIOD .
OriginManifestType OriginManifestType
noSmithyDocumentSerde
}
// Dash manifest configuration parameters.
type DashPlaylistSettings struct {
// The total duration (in seconds) of each manifest. Minimum value: 30 seconds.
// Maximum value: 3600 seconds.
ManifestWindowSeconds int32
// Minimum amount of content (measured in seconds) that a player must keep
// available in the buffer. Minimum value: 2 seconds. Maximum value: 60 seconds.
MinBufferTimeSeconds int32
// Minimum amount of time (in seconds) that the player should wait before
// requesting updates to the manifest. Minimum value: 2 seconds. Maximum value: 60
// seconds.
MinUpdatePeriodSeconds int32
// Amount of time (in seconds) that the player should be from the live point at
// the end of the manifest. Minimum value: 2 seconds. Maximum value: 60 seconds.
SuggestedPresentationDelaySeconds int32
noSmithyDocumentSerde
}
// The optional configuration for a server that serves segments. Use this if you
// want the segment delivery server to be different from the source location
// server. For example, you can configure your source location server to be an
// origination server, such as MediaPackage, and the segment delivery server to be
// a content delivery network (CDN), such as CloudFront. If you don't specify a
// segment delivery server, then the source location server is used.
type DefaultSegmentDeliveryConfiguration struct {
// The hostname of the server that will be used to serve segments. This string
// must include the protocol, such as https://.
BaseUrl *string
noSmithyDocumentSerde
}
// The configuration for HLS content.
type HlsConfiguration struct {
// The URL that is used to initiate a playback session for devices that support
// Apple HLS. The session uses server-side reporting.
ManifestEndpointPrefix *string
noSmithyDocumentSerde
}
// HLS playlist configuration parameters.
type HlsPlaylistSettings struct {
// The total duration (in seconds) of each manifest. Minimum value: 30 seconds.
// Maximum value: 3600 seconds.
ManifestWindowSeconds int32
noSmithyDocumentSerde
}
// The HTTP configuration for the source location.
type HttpConfiguration struct {
// The base URL for the source location host server. This string must include the
// protocol, such as https://.
//
// This member is required.
BaseUrl *string
noSmithyDocumentSerde
}
// The HTTP package configuration properties for the requested VOD source.
type HttpPackageConfiguration struct {
// The relative path to the URL for this VOD source. This is combined with
// SourceLocation::HttpConfiguration::BaseUrl to form a valid URL.
//
// This member is required.
Path *string
// The name of the source group. This has to match one of the
// Channel::Outputs::SourceGroup .
//
// This member is required.
SourceGroup *string
// The streaming protocol for this package configuration. Supported values are HLS
// and DASH .
//
// This member is required.
Type Type
noSmithyDocumentSerde
}
// The configuration for pre-roll ad insertion.
type LivePreRollConfiguration struct {
// The URL for the ad decision server (ADS) for pre-roll ads. This includes the
// specification of static parameters and placeholders for dynamic parameters. AWS
// Elemental MediaTailor substitutes player-specific and session-specific
// parameters as needed when calling the ADS. Alternately, for testing, you can
// provide a static VAST URL. The maximum length is 25,000 characters.
AdDecisionServerUrl *string
// The maximum allowed duration for the pre-roll ad avail. AWS Elemental
// MediaTailor won't play pre-roll ads to exceed this duration, regardless of the
// total duration of ads that the ADS returns.
MaxDurationSeconds int32
noSmithyDocumentSerde
}
// Live source configuration parameters.
type LiveSource struct {
// The ARN for the live source.
//
// This member is required.
Arn *string
// The HTTP package configurations for the live source.
//
// This member is required.
HttpPackageConfigurations []HttpPackageConfiguration
// The name that's used to refer to a live source.
//
// This member is required.
LiveSourceName *string
// The name of the source location.
//
// This member is required.
SourceLocationName *string
// The timestamp that indicates when the live source was created.
CreationTime *time.Time
// The timestamp that indicates when the live source was last modified.
LastModifiedTime *time.Time
// The tags assigned to the live source. Tags are key-value pairs that you can
// associate with Amazon resources to help with organization, access control, and
// cost tracking. For more information, see Tagging AWS Elemental MediaTailor
// Resources (https://docs.aws.amazon.com/mediatailor/latest/ug/tagging.html) .
Tags map[string]string
noSmithyDocumentSerde
}
// Returns Amazon CloudWatch log settings for a playback configuration.
type LogConfiguration struct {
// The percentage of session logs that MediaTailor sends to your Cloudwatch Logs
// account. For example, if your playback configuration has 1000 sessions and
// percentEnabled is set to 60 , MediaTailor sends logs for 600 of the sessions to
// CloudWatch Logs. MediaTailor decides at random which of the playback
// configuration sessions to send logs for. If you want to view logs for a specific
// session, you can use the debug log mode (https://docs.aws.amazon.com/mediatailor/latest/ug/debug-log-mode.html)
// . Valid values: 0 - 100
//
// This member is required.
PercentEnabled int32
noSmithyDocumentSerde
}
// The log configuration for the channel.
type LogConfigurationForChannel struct {
// The log types.
LogTypes []LogType
noSmithyDocumentSerde
}
// The configuration for manifest processing rules. Manifest processing rules
// enable customization of the personalized manifests created by MediaTailor.
type ManifestProcessingRules struct {
// For HLS, when set to true , MediaTailor passes through EXT-X-CUE-IN ,
// EXT-X-CUE-OUT , and EXT-X-SPLICEPOINT-SCTE35 ad markers from the origin
// manifest to the MediaTailor personalized manifest. No logic is applied to these
// ad markers. For example, if EXT-X-CUE-OUT has a value of 60 , but no ads are
// filled for that ad break, MediaTailor will not set the value to 0 .
AdMarkerPassthrough *AdMarkerPassthrough
noSmithyDocumentSerde
}
// A playback configuration. For information about MediaTailor configurations, see
// Working with configurations in AWS Elemental MediaTailor (https://docs.aws.amazon.com/mediatailor/latest/ug/configurations.html)
// .
type PlaybackConfiguration struct {
// The URL for the ad decision server (ADS). This includes the specification of
// static parameters and placeholders for dynamic parameters. AWS Elemental
// MediaTailor substitutes player-specific and session-specific parameters as
// needed when calling the ADS. Alternately, for testing you can provide a static
// VAST URL. The maximum length is 25,000 characters.
AdDecisionServerUrl *string
// The configuration for avail suppression, also known as ad suppression. For more
// information about ad suppression, see Ad Suppression (https://docs.aws.amazon.com/mediatailor/latest/ug/ad-behavior.html)
// .
AvailSuppression *AvailSuppression
// The configuration for bumpers. Bumpers are short audio or video clips that play
// at the start or before the end of an ad break. To learn more about bumpers, see
// Bumpers (https://docs.aws.amazon.com/mediatailor/latest/ug/bumpers.html) .
Bumper *Bumper
// The configuration for using a content delivery network (CDN), like Amazon
// CloudFront, for content and ad segment management.
CdnConfiguration *CdnConfiguration
// The player parameters and aliases used as dynamic variables during session
// initialization. For more information, see Domain Variables (https://docs.aws.amazon.com/mediatailor/latest/ug/variables-domain.html)
// .
ConfigurationAliases map[string]map[string]string
// The configuration for a DASH source.
DashConfiguration *DashConfiguration
// The configuration for HLS content.
HlsConfiguration *HlsConfiguration
// The configuration for pre-roll ad insertion.
LivePreRollConfiguration *LivePreRollConfiguration
// The Amazon CloudWatch log settings for a playback configuration.
LogConfiguration *LogConfiguration
// The configuration for manifest processing rules. Manifest processing rules
// enable customization of the personalized manifests created by MediaTailor.
ManifestProcessingRules *ManifestProcessingRules
// The identifier for the playback configuration.
Name *string
// Defines the maximum duration of underfilled ad time (in seconds) allowed in an
// ad break. If the duration of underfilled ad time exceeds the personalization
// threshold, then the personalization of the ad break is abandoned and the
// underlying content is shown. This feature applies to ad replacement in live and
// VOD streams, rather than ad insertion, because it relies on an underlying
// content stream. For more information about ad break behavior, including ad
// replacement and insertion, see Ad Behavior in AWS Elemental MediaTailor (https://docs.aws.amazon.com/mediatailor/latest/ug/ad-behavior.html)
// .
PersonalizationThresholdSeconds int32
// The Amazon Resource Name (ARN) for the playback configuration.
PlaybackConfigurationArn *string
// The URL that the player accesses to get a manifest from AWS Elemental
// MediaTailor.
PlaybackEndpointPrefix *string
// The URL that the player uses to initialize a session that uses client-side
// reporting.
SessionInitializationEndpointPrefix *string
// The URL for a video asset to transcode and use to fill in time that's not used
// by ads. AWS Elemental MediaTailor shows the slate to fill in gaps in media
// content. Configuring the slate is optional for non-VPAID playback
// configurations. For VPAID, the slate is required because MediaTailor provides it
// in the slots designated for dynamic ad content. The slate must be a high-quality
// asset that contains both audio and video.
SlateAdUrl *string
// The tags to assign to the playback configuration. Tags are key-value pairs that
// you can associate with Amazon resources to help with organization, access
// control, and cost tracking. For more information, see Tagging AWS Elemental
// MediaTailor Resources (https://docs.aws.amazon.com/mediatailor/latest/ug/tagging.html)
// .
Tags map[string]string
// The name that is used to associate this playback configuration with a custom
// transcode profile. This overrides the dynamic transcoding defaults of
// MediaTailor. Use this only if you have already set up custom profiles with the
// help of AWS Support.
TranscodeProfileName *string
// The URL prefix for the parent manifest for the stream, minus the asset ID. The
// maximum length is 512 characters.
VideoContentSourceUrl *string
noSmithyDocumentSerde
}
// A complex type that contains settings that determine how and when that
// MediaTailor places prefetched ads into upcoming ad breaks.
type PrefetchConsumption struct {
// The time when MediaTailor no longer considers the prefetched ads for use in an
// ad break. MediaTailor automatically deletes prefetch schedules no less than
// seven days after the end time. If you'd like to manually delete the prefetch
// schedule, you can call DeletePrefetchSchedule .
//
// This member is required.
EndTime *time.Time
// If you only want MediaTailor to insert prefetched ads into avails (ad breaks)
// that match specific dynamic variables, such as scte.event_id , set the avail
// matching criteria.
AvailMatchingCriteria []AvailMatchingCriteria
// The time when prefetched ads are considered for use in an ad break. If you
// don't specify StartTime , the prefetched ads are available after MediaTailor
// retrives them from the ad decision server.
StartTime *time.Time
noSmithyDocumentSerde
}
// A complex type that contains settings governing when MediaTailor prefetches
// ads, and which dynamic variables that MediaTailor includes in the request to the
// ad decision server.
type PrefetchRetrieval struct {
// The time when prefetch retrieval ends for the ad break. Prefetching will be
// attempted for manifest requests that occur at or before this time.
//
// This member is required.
EndTime *time.Time
// The dynamic variables to use for substitution during prefetch requests to the
// ad decision server (ADS). You initially configure dynamic variables (https://docs.aws.amazon.com/mediatailor/latest/ug/variables.html)
// for the ADS URL when you set up your playback configuration. When you specify
// DynamicVariables for prefetch retrieval, MediaTailor includes the dynamic
// variables in the request to the ADS.
DynamicVariables map[string]string
// The time when prefetch retrievals can start for this break. Ad prefetching will
// be attempted for manifest requests that occur at or after this time. Defaults to
// the current time. If not specified, the prefetch retrieval starts as soon as
// possible.
StartTime *time.Time
noSmithyDocumentSerde
}
// A prefetch schedule allows you to tell MediaTailor to fetch and prepare certain
// ads before an ad break happens. For more information about ad prefetching, see
// Using ad prefetching (https://docs.aws.amazon.com/mediatailor/latest/ug/prefetching-ads.html)
// in the MediaTailor User Guide.
type PrefetchSchedule struct {
// The Amazon Resource Name (ARN) of the prefetch schedule.
//
// This member is required.
Arn *string
// Consumption settings determine how, and when, MediaTailor places the prefetched
// ads into ad breaks. Ad consumption occurs within a span of time that you define,
// called a consumption window. You can designate which ad breaks that MediaTailor
// fills with prefetch ads by setting avail matching criteria.
//
// This member is required.
Consumption *PrefetchConsumption
// The name of the prefetch schedule. The name must be unique among all prefetch
// schedules that are associated with the specified playback configuration.
//
// This member is required.
Name *string
// The name of the playback configuration to create the prefetch schedule for.
//
// This member is required.
PlaybackConfigurationName *string
// A complex type that contains settings for prefetch retrieval from the ad
// decision server (ADS).
//
// This member is required.
Retrieval *PrefetchRetrieval
// An optional stream identifier that you can specify in order to prefetch for
// multiple streams that use the same playback configuration.
StreamId *string
noSmithyDocumentSerde
}
// The output configuration for this channel.
type RequestOutputItem struct {
// The name of the manifest for the channel. The name appears in the PlaybackUrl .
//
// This member is required.
ManifestName *string
// A string used to match which HttpPackageConfiguration is used for each VodSource
// .
//
// This member is required.
SourceGroup *string
// DASH manifest configuration parameters.
DashPlaylistSettings *DashPlaylistSettings
// HLS playlist configuration parameters.
HlsPlaylistSettings *HlsPlaylistSettings
noSmithyDocumentSerde
}
// The output item response.
type ResponseOutputItem struct {
// The name of the manifest for the channel that will appear in the channel
// output's playback URL.
//
// This member is required.
ManifestName *string
// The URL used for playback by content players.
//
// This member is required.
PlaybackUrl *string
// A string used to associate a package configuration source group with a channel
// output.
//
// This member is required.
SourceGroup *string
// DASH manifest configuration settings.
DashPlaylistSettings *DashPlaylistSettings
// HLS manifest configuration settings.
HlsPlaylistSettings *HlsPlaylistSettings
noSmithyDocumentSerde
}
// The schedule's ad break properties.
type ScheduleAdBreak struct {
// The approximate duration of the ad break, in seconds.
ApproximateDurationSeconds int64
// The approximate time that the ad will start playing.
ApproximateStartTime *time.Time
// The name of the source location containing the VOD source used for the ad break.
SourceLocationName *string
// The name of the VOD source used for the ad break.
VodSourceName *string
noSmithyDocumentSerde
}
// Schedule configuration parameters. A channel must be stopped before changes can
// be made to the schedule.
type ScheduleConfiguration struct {
// Program transition configurations.
//
// This member is required.
Transition *Transition
// Program clip range configuration.
ClipRange *ClipRange
noSmithyDocumentSerde
}
// The properties for a schedule.
type ScheduleEntry struct {
// The ARN of the program.
//
// This member is required.
Arn *string
// The name of the channel that uses this schedule.
//
// This member is required.
ChannelName *string
// The name of the program.
//
// This member is required.
ProgramName *string
// The name of the source location.
//
// This member is required.
SourceLocationName *string
// The approximate duration of this program, in seconds.
ApproximateDurationSeconds int64
// The approximate time that the program will start playing.
ApproximateStartTime *time.Time
// The name of the live source used for the program.
LiveSourceName *string
// The schedule's ad break properties.
ScheduleAdBreaks []ScheduleAdBreak
// The type of schedule entry.
ScheduleEntryType ScheduleEntryType
// The name of the VOD source.
VodSourceName *string
noSmithyDocumentSerde
}
// AWS Secrets Manager access token configuration parameters. For information
// about Secrets Manager access token authentication, see Working with AWS Secrets
// Manager access token authentication (https://docs.aws.amazon.com/mediatailor/latest/ug/channel-assembly-access-configuration-access-token.html)
// .
type SecretsManagerAccessTokenConfiguration struct {
// The name of the HTTP header used to supply the access token in requests to the
// source location.
HeaderName *string
// The Amazon Resource Name (ARN) of the AWS Secrets Manager secret that contains
// the access token.
SecretArn *string
// The AWS Secrets Manager SecretString (https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_CreateSecret.html#SecretsManager-CreateSecret-request-SecretString.html)
// key associated with the access token. MediaTailor uses the key to look up
// SecretString key and value pair containing the access token.
SecretStringKey *string
noSmithyDocumentSerde
}
// The segmentation_descriptor message can contain advanced metadata fields, like
// content identifiers, to convey a wide range of information about the ad break.
// MediaTailor writes the ad metadata in the egress manifest as part of the
// EXT-X-DATERANGE or EventStream ad marker's SCTE-35 data. segmentation_descriptor
// messages must be sent with the time_signal message type. See the
// segmentation_descriptor() table of the 2022 SCTE-35 specification for more
// information.
type SegmentationDescriptor struct {
// The segment number to assign to the segmentation_descriptor.segment_num
// message, as defined in section 10.3.3.1 of the 2022 SCTE-35 specification Values
// must be between 0 and 256, inclusive. The default value is 0.
SegmentNum *int32
// The Event Identifier to assign to the
// segmentation_descriptor.segmentation_event_id message, as defined in section
// 10.3.3.1 of the 2022 SCTE-35 specification. The default value is 1.
SegmentationEventId *int32
// The Type Identifier to assign to the
// segmentation_descriptor.segmentation_type_id message, as defined in section
// 10.3.3.1 of the 2022 SCTE-35 specification. Values must be between 0 and 256,
// inclusive. The default value is 48.
SegmentationTypeId *int32
// The Upid to assign to the segmentation_descriptor.segmentation_upid message, as
// defined in section 10.3.3.1 of the 2022 SCTE-35 specification. The value must be
// a hexadecimal string containing only the characters 0 though 9 and A through F.
// The default value is "" (an empty string).
SegmentationUpid *string
// The Upid Type to assign to the segmentation_descriptor.segmentation_upid_type
// message, as defined in section 10.3.3.1 of the 2022 SCTE-35 specification.
// Values must be between 0 and 256, inclusive. The default value is 14.
SegmentationUpidType *int32
// The number of segments expected, which is assigned to the
// segmentation_descriptor.segments_expectedS message, as defined in section
// 10.3.3.1 of the 2022 SCTE-35 specification Values must be between 0 and 256,
// inclusive. The default value is 0.
SegmentsExpected *int32
// The sub-segment number to assign to the segmentation_descriptor.sub_segment_num
// message, as defined in section 10.3.3.1 of the 2022 SCTE-35 specification.
// Values must be between 0 and 256, inclusive. The defualt value is null.
SubSegmentNum *int32
// The number of sub-segments expected, which is assigned to the
// segmentation_descriptor.sub_segments_expected message, as defined in section
// 10.3.3.1 of the 2022 SCTE-35 specification. Values must be between 0 and 256,
// inclusive. The default value is null.
SubSegmentsExpected *int32
noSmithyDocumentSerde
}
// The segment delivery configuration settings.
type SegmentDeliveryConfiguration struct {
// The base URL of the host or path of the segment delivery server that you're
// using to serve segments. This is typically a content delivery network (CDN). The
// URL can be absolute or relative. To use an absolute URL include the protocol,
// such as https://example.com/some/path . To use a relative URL specify the
// relative path, such as /some/path* .
BaseUrl *string
// A unique identifier used to distinguish between multiple segment delivery
// configurations in a source location.
Name *string
noSmithyDocumentSerde
}
// Slate VOD source configuration.
type SlateSource struct {
// The name of the source location where the slate VOD source is stored.
SourceLocationName *string
// The slate VOD source name. The VOD source must already exist in a source
// location before it can be used for slate.
VodSourceName *string
noSmithyDocumentSerde
}
// A source location is a container for sources. For more information about source
// locations, see Working with source locations (https://docs.aws.amazon.com/mediatailor/latest/ug/channel-assembly-source-locations.html)
// in the MediaTailor User Guide.
type SourceLocation struct {
// The ARN of the SourceLocation.
//
// This member is required.
Arn *string
// The HTTP configuration for the source location.
//
// This member is required.
HttpConfiguration *HttpConfiguration
// The name of the source location.
//
// This member is required.
SourceLocationName *string
// The access configuration for the source location.
AccessConfiguration *AccessConfiguration
// The timestamp that indicates when the source location was created.
CreationTime *time.Time
// The default segment delivery configuration.
DefaultSegmentDeliveryConfiguration *DefaultSegmentDeliveryConfiguration
// The timestamp that indicates when the source location was last modified.
LastModifiedTime *time.Time
// The segment delivery configurations for the source location.
SegmentDeliveryConfigurations []SegmentDeliveryConfiguration
// The tags assigned to the source location. Tags are key-value pairs that you can
// associate with Amazon resources to help with organization, access control, and
// cost tracking. For more information, see Tagging AWS Elemental MediaTailor
// Resources (https://docs.aws.amazon.com/mediatailor/latest/ug/tagging.html) .
Tags map[string]string
noSmithyDocumentSerde
}
// Splice insert message configuration.
type SpliceInsertMessage struct {
// This is written to splice_insert.avail_num , as defined in section 9.7.3.1 of
// the SCTE-35 specification. The default value is 0 . Values must be between 0
// and 256 , inclusive.
AvailNum int32
// This is written to splice_insert.avails_expected , as defined in section 9.7.3.1
// of the SCTE-35 specification. The default value is 0 . Values must be between 0
// and 256 , inclusive.
AvailsExpected int32
// This is written to splice_insert.splice_event_id , as defined in section 9.7.3.1
// of the SCTE-35 specification. The default value is 1 .
SpliceEventId int32
// This is written to splice_insert.unique_program_id , as defined in section
// 9.7.3.1 of the SCTE-35 specification. The default value is 0 . Values must be
// between 0 and 256 , inclusive.
UniqueProgramId int32
noSmithyDocumentSerde
}
// The SCTE-35 time_signal message can be sent with one or more
// segmentation_descriptor messages. A time_signal message can be sent only if a
// single segmentation_descriptor message is sent. The time_signal message
// contains only the splice_time field which is constructed using a given
// presentation timestamp. When sending a time_signal message, the
// splice_command_type field in the splice_info_section message is set to 6
// (0x06). See the time_signal() table of the 2022 SCTE-35 specification for more
// information.
type TimeSignalMessage struct {
// The configurations for the SCTE-35 segmentation_descriptor message(s) sent with
// the time_signal message.
SegmentationDescriptors []SegmentationDescriptor
noSmithyDocumentSerde
}
// Program transition configuration.
type Transition struct {
// The position where this program will be inserted relative to the
// RelativePosition .
//
// This member is required.
RelativePosition RelativePosition
// Defines when the program plays in the schedule. You can set the value to
// ABSOLUTE or RELATIVE . ABSOLUTE - The program plays at a specific wall clock
// time. This setting can only be used for channels using the LINEAR PlaybackMode .
// Note the following considerations when using ABSOLUTE transitions: If the
// preceding program in the schedule has a duration that extends past the wall
// clock time, MediaTailor truncates the preceding program on a common segment
// boundary. If there are gaps in playback, MediaTailor plays the FillerSlate you
// configured for your linear channel. RELATIVE - The program is inserted into the
// schedule either before or after a program that you specify via RelativePosition .
//
// This member is required.
Type *string
// The duration of the live program in seconds.
DurationMillis int64
// The name of the program that this program will be inserted next to, as defined
// by RelativePosition .
RelativeProgram *string
// The date and time that the program is scheduled to start, in epoch milliseconds.
ScheduledStartTimeMillis int64
noSmithyDocumentSerde
}
// Schedule configuration parameters.
type UpdateProgramScheduleConfiguration struct {
// Program clip range configuration.
ClipRange *ClipRange
// Program transition configuration.
Transition *UpdateProgramTransition
noSmithyDocumentSerde
}
// Program transition configuration.
type UpdateProgramTransition struct {
// The duration of the live program in seconds.
DurationMillis int64
// The date and time that the program is scheduled to start, in epoch milliseconds.
ScheduledStartTimeMillis int64
noSmithyDocumentSerde
}
// VOD source configuration parameters.
type VodSource struct {
// The ARN for the VOD source.
//
// This member is required.
Arn *string
// The HTTP package configurations for the VOD source.
//
// This member is required.
HttpPackageConfigurations []HttpPackageConfiguration
// The name of the source location that the VOD source is associated with.
//
// This member is required.
SourceLocationName *string
// The name of the VOD source.
//
// This member is required.
VodSourceName *string
// The timestamp that indicates when the VOD source was created.
CreationTime *time.Time
// The timestamp that indicates when the VOD source was last modified.
LastModifiedTime *time.Time
// The tags assigned to the VOD source. Tags are key-value pairs that you can
// associate with Amazon resources to help with organization, access control, and
// cost tracking. For more information, see Tagging AWS Elemental MediaTailor
// Resources (https://docs.aws.amazon.com/mediatailor/latest/ug/tagging.html) .
Tags map[string]string
noSmithyDocumentSerde
}
type noSmithyDocumentSerde = smithydocument.NoSerde
| 1,141 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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 = "MemoryDB"
const ServiceAPIVersion = "2021-01-01"
// Client provides the API client to make operations call for Amazon MemoryDB.
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, "memorydb", 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 memorydb
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 memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Apply the service update to a list of clusters supplied. For more information
// on service updates and applying them, see Applying the service updates (https://docs.aws.amazon.com/MemoryDB/latest/devguide/managing-updates.html#applying-updates)
// .
func (c *Client) BatchUpdateCluster(ctx context.Context, params *BatchUpdateClusterInput, optFns ...func(*Options)) (*BatchUpdateClusterOutput, error) {
if params == nil {
params = &BatchUpdateClusterInput{}
}
result, metadata, err := c.invokeOperation(ctx, "BatchUpdateCluster", params, optFns, c.addOperationBatchUpdateClusterMiddlewares)
if err != nil {
return nil, err
}
out := result.(*BatchUpdateClusterOutput)
out.ResultMetadata = metadata
return out, nil
}
type BatchUpdateClusterInput struct {
// The cluster names to apply the updates.
//
// This member is required.
ClusterNames []string
// The unique ID of the service update
ServiceUpdate *types.ServiceUpdateRequest
noSmithyDocumentSerde
}
type BatchUpdateClusterOutput struct {
// The list of clusters that have been updated.
ProcessedClusters []types.Cluster
// The list of clusters where updates have not been applied.
UnprocessedClusters []types.UnprocessedCluster
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationBatchUpdateClusterMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpBatchUpdateCluster{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpBatchUpdateCluster{}, 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 = addOpBatchUpdateClusterValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opBatchUpdateCluster(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_opBatchUpdateCluster(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "BatchUpdateCluster",
}
}
| 133 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Makes a copy of an existing snapshot.
func (c *Client) CopySnapshot(ctx context.Context, params *CopySnapshotInput, optFns ...func(*Options)) (*CopySnapshotOutput, error) {
if params == nil {
params = &CopySnapshotInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CopySnapshot", params, optFns, c.addOperationCopySnapshotMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CopySnapshotOutput)
out.ResultMetadata = metadata
return out, nil
}
type CopySnapshotInput struct {
// The name of an existing snapshot from which to make a copy.
//
// This member is required.
SourceSnapshotName *string
// A name for the snapshot copy. MemoryDB does not permit overwriting a snapshot,
// therefore this name must be unique within its context - MemoryDB or an Amazon S3
// bucket if exporting.
//
// This member is required.
TargetSnapshotName *string
// The ID of the KMS key used to encrypt the target snapshot.
KmsKeyId *string
// A list of tags to be added to this resource. A tag is a key-value pair. A tag
// key must be accompanied by a tag value, although null is accepted.
Tags []types.Tag
// The Amazon S3 bucket to which the snapshot is exported. This parameter is used
// only when exporting a snapshot for external access. When using this parameter to
// export a snapshot, be sure MemoryDB has the needed permissions to this S3
// bucket. For more information, see Step 2: Grant MemoryDB Access to Your Amazon
// S3 Bucket (https://docs.aws.amazon.com/MemoryDB/latest/devguide/snapshots-exporting.html)
// .
TargetBucket *string
noSmithyDocumentSerde
}
type CopySnapshotOutput struct {
// Represents a copy of an entire cluster as of the time when the snapshot was
// taken.
Snapshot *types.Snapshot
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCopySnapshotMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCopySnapshot{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCopySnapshot{}, 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 = addOpCopySnapshotValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCopySnapshot(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_opCopySnapshot(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "CopySnapshot",
}
}
| 148 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an Access Control List. For more information, see Authenticating users
// with Access Contol Lists (ACLs) (https://docs.aws.amazon.com/MemoryDB/latest/devguide/clusters.acls.html)
// .
func (c *Client) CreateACL(ctx context.Context, params *CreateACLInput, optFns ...func(*Options)) (*CreateACLOutput, error) {
if params == nil {
params = &CreateACLInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateACL", params, optFns, c.addOperationCreateACLMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateACLOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateACLInput struct {
// The name of the Access Control List.
//
// This member is required.
ACLName *string
// A list of tags to be added to this resource. A tag is a key-value pair. A tag
// key must be accompanied by a tag value, although null is accepted.
Tags []types.Tag
// The list of users that belong to the Access Control List.
UserNames []string
noSmithyDocumentSerde
}
type CreateACLOutput struct {
// The newly-created Access Control List.
ACL *types.ACL
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateACLMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateACL{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateACL{}, 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 = addOpCreateACLValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateACL(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_opCreateACL(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "CreateACL",
}
}
| 134 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a cluster. All nodes in the cluster run the same protocol-compliant
// engine software.
func (c *Client) CreateCluster(ctx context.Context, params *CreateClusterInput, optFns ...func(*Options)) (*CreateClusterOutput, error) {
if params == nil {
params = &CreateClusterInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateCluster", params, optFns, c.addOperationCreateClusterMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateClusterOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateClusterInput struct {
// The name of the Access Control List to associate with the cluster.
//
// This member is required.
ACLName *string
// The name of the cluster. This value must be unique as it also serves as the
// cluster identifier.
//
// This member is required.
ClusterName *string
// The compute and memory capacity of the nodes in the cluster.
//
// This member is required.
NodeType *string
// When set to true, the cluster will automatically receive minor engine version
// upgrades after launch.
AutoMinorVersionUpgrade *bool
// Enables data tiering. Data tiering is only supported for clusters using the
// r6gd node type. This parameter must be set when using r6gd nodes. For more
// information, see Data tiering (https://docs.aws.amazon.com/memorydb/latest/devguide/data-tiering.html)
// .
DataTiering *bool
// An optional description of the cluster.
Description *string
// The version number of the Redis engine to be used for the cluster.
EngineVersion *string
// The ID of the KMS key used to encrypt the cluster.
KmsKeyId *string
// Specifies the weekly time range during which maintenance on the cluster is
// performed. It is specified as a range in the format ddd:hh24:mi-ddd:hh24:mi (24H
// Clock UTC). The minimum maintenance window is a 60 minute period. Valid values
// for ddd are:
// - sun
// - mon
// - tue
// - wed
// - thu
// - fri
// - sat
// Example: sun:23:00-mon:01:30
MaintenanceWindow *string
// The number of replicas to apply to each shard. The default value is 1. The
// maximum is 5.
NumReplicasPerShard *int32
// The number of shards the cluster will contain. The default value is 1.
NumShards *int32
// The name of the parameter group associated with the cluster.
ParameterGroupName *string
// The port number on which each of the nodes accepts connections.
Port *int32
// A list of security group names to associate with this cluster.
SecurityGroupIds []string
// A list of Amazon Resource Names (ARN) that uniquely identify the RDB snapshot
// files stored in Amazon S3. The snapshot files are used to populate the new
// cluster. The Amazon S3 object name in the ARN cannot contain any commas.
SnapshotArns []string
// The name of a snapshot from which to restore data into the new cluster. The
// snapshot status changes to restoring while the new cluster is being created.
SnapshotName *string
// The number of days for which MemoryDB retains automatic snapshots before
// deleting them. For example, if you set SnapshotRetentionLimit to 5, a snapshot
// that was taken today is retained for 5 days before being deleted.
SnapshotRetentionLimit *int32
// The daily time range (in UTC) during which MemoryDB begins taking a daily
// snapshot of your shard. Example: 05:00-09:00 If you do not specify this
// parameter, MemoryDB automatically chooses an appropriate time range.
SnapshotWindow *string
// The Amazon Resource Name (ARN) of the Amazon Simple Notification Service (SNS)
// topic to which notifications are sent.
SnsTopicArn *string
// The name of the subnet group to be used for the cluster.
SubnetGroupName *string
// A flag to enable in-transit encryption on the cluster.
TLSEnabled *bool
// A list of tags to be added to this resource. Tags are comma-separated key,value
// pairs (e.g. Key=myKey, Value=myKeyValue. You can include multiple tags as shown
// following: Key=myKey, Value=myKeyValue Key=mySecondKey, Value=mySecondKeyValue.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateClusterOutput struct {
// The newly-created cluster.
Cluster *types.Cluster
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateClusterMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateCluster{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateCluster{}, 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 = addOpCreateClusterValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateCluster(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_opCreateCluster(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "CreateCluster",
}
}
| 220 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a new MemoryDB parameter group. A parameter group is a collection of
// parameters and their values that are applied to all of the nodes in any cluster.
// For more information, see Configuring engine parameters using parameter groups (https://docs.aws.amazon.com/MemoryDB/latest/devguide/parametergroups.html)
// .
func (c *Client) CreateParameterGroup(ctx context.Context, params *CreateParameterGroupInput, optFns ...func(*Options)) (*CreateParameterGroupOutput, error) {
if params == nil {
params = &CreateParameterGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateParameterGroup", params, optFns, c.addOperationCreateParameterGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateParameterGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateParameterGroupInput struct {
// The name of the parameter group family that the parameter group can be used
// with.
//
// This member is required.
Family *string
// The name of the parameter group.
//
// This member is required.
ParameterGroupName *string
// An optional description of the parameter group.
Description *string
// A list of tags to be added to this resource. A tag is a key-value pair. A tag
// key must be accompanied by a tag value, although null is accepted.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateParameterGroupOutput struct {
// The newly-created parameter group.
ParameterGroup *types.ParameterGroup
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateParameterGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateParameterGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateParameterGroup{}, 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 = addOpCreateParameterGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateParameterGroup(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_opCreateParameterGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "CreateParameterGroup",
}
}
| 141 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a copy of an entire cluster at a specific moment in time.
func (c *Client) CreateSnapshot(ctx context.Context, params *CreateSnapshotInput, optFns ...func(*Options)) (*CreateSnapshotOutput, error) {
if params == nil {
params = &CreateSnapshotInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateSnapshot", params, optFns, c.addOperationCreateSnapshotMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateSnapshotOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateSnapshotInput struct {
// The snapshot is created from this cluster.
//
// This member is required.
ClusterName *string
// A name for the snapshot being created.
//
// This member is required.
SnapshotName *string
// The ID of the KMS key used to encrypt the snapshot.
KmsKeyId *string
// A list of tags to be added to this resource. A tag is a key-value pair. A tag
// key must be accompanied by a tag value, although null is accepted.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateSnapshotOutput struct {
// The newly-created snapshot.
Snapshot *types.Snapshot
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateSnapshotMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateSnapshot{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateSnapshot{}, 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 = addOpCreateSnapshotValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateSnapshot(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_opCreateSnapshot(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "CreateSnapshot",
}
}
| 137 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a subnet group. A subnet group is a collection of subnets (typically
// private) that you can designate for your clusters running in an Amazon Virtual
// Private Cloud (VPC) environment. When you create a cluster in an Amazon VPC, you
// must specify a subnet group. MemoryDB uses that subnet group to choose a subnet
// and IP addresses within that subnet to associate with your nodes. For more
// information, see Subnets and subnet groups (https://docs.aws.amazon.com/MemoryDB/latest/devguide/subnetgroups.html)
// .
func (c *Client) CreateSubnetGroup(ctx context.Context, params *CreateSubnetGroupInput, optFns ...func(*Options)) (*CreateSubnetGroupOutput, error) {
if params == nil {
params = &CreateSubnetGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateSubnetGroup", params, optFns, c.addOperationCreateSubnetGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateSubnetGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateSubnetGroupInput struct {
// The name of the subnet group.
//
// This member is required.
SubnetGroupName *string
// A list of VPC subnet IDs for the subnet group.
//
// This member is required.
SubnetIds []string
// A description for the subnet group.
Description *string
// A list of tags to be added to this resource. A tag is a key-value pair. A tag
// key must be accompanied by a tag value, although null is accepted.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateSubnetGroupOutput struct {
// The newly-created subnet group
SubnetGroup *types.SubnetGroup
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateSubnetGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateSubnetGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateSubnetGroup{}, 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 = addOpCreateSubnetGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateSubnetGroup(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_opCreateSubnetGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "CreateSubnetGroup",
}
}
| 143 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a MemoryDB user. For more information, see Authenticating users with
// Access Contol Lists (ACLs) (https://docs.aws.amazon.com/MemoryDB/latest/devguide/clusters.acls.html)
// .
func (c *Client) CreateUser(ctx context.Context, params *CreateUserInput, optFns ...func(*Options)) (*CreateUserOutput, error) {
if params == nil {
params = &CreateUserInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateUser", params, optFns, c.addOperationCreateUserMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateUserOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateUserInput struct {
// Access permissions string used for this user.
//
// This member is required.
AccessString *string
// Denotes the user's authentication properties, such as whether it requires a
// password to authenticate.
//
// This member is required.
AuthenticationMode *types.AuthenticationMode
// The name of the user. This value must be unique as it also serves as the user
// identifier.
//
// This member is required.
UserName *string
// A list of tags to be added to this resource. A tag is a key-value pair. A tag
// key must be accompanied by a tag value, although null is accepted.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateUserOutput struct {
// The newly-created user.
User *types.User
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateUserMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateUser{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateUser{}, 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 = addOpCreateUserValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateUser(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_opCreateUser(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "CreateUser",
}
}
| 143 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an Access Control List. The ACL must first be disassociated from the
// cluster before it can be deleted. For more information, see Authenticating
// users with Access Contol Lists (ACLs) (https://docs.aws.amazon.com/MemoryDB/latest/devguide/clusters.acls.html)
// .
func (c *Client) DeleteACL(ctx context.Context, params *DeleteACLInput, optFns ...func(*Options)) (*DeleteACLOutput, error) {
if params == nil {
params = &DeleteACLInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteACL", params, optFns, c.addOperationDeleteACLMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteACLOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteACLInput struct {
// The name of the Access Control List to delete
//
// This member is required.
ACLName *string
noSmithyDocumentSerde
}
type DeleteACLOutput struct {
// The Access Control List object that has been deleted.
ACL *types.ACL
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteACLMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteACL{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteACL{}, 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 = addOpDeleteACLValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteACL(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_opDeleteACL(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "DeleteACL",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a cluster. It also deletes all associated nodes and node endpoints
func (c *Client) DeleteCluster(ctx context.Context, params *DeleteClusterInput, optFns ...func(*Options)) (*DeleteClusterOutput, error) {
if params == nil {
params = &DeleteClusterInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteCluster", params, optFns, c.addOperationDeleteClusterMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteClusterOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteClusterInput struct {
// The name of the cluster to be deleted
//
// This member is required.
ClusterName *string
// The user-supplied name of a final cluster snapshot. This is the unique name
// that identifies the snapshot. MemoryDB creates the snapshot, and then deletes
// the cluster immediately afterward.
FinalSnapshotName *string
noSmithyDocumentSerde
}
type DeleteClusterOutput struct {
// The cluster object that has been deleted
Cluster *types.Cluster
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteClusterMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteCluster{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteCluster{}, 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 = addOpDeleteClusterValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteCluster(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_opDeleteCluster(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "DeleteCluster",
}
}
| 130 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the specified parameter group. You cannot delete a parameter group if
// it is associated with any clusters. You cannot delete the default parameter
// groups in your account.
func (c *Client) DeleteParameterGroup(ctx context.Context, params *DeleteParameterGroupInput, optFns ...func(*Options)) (*DeleteParameterGroupOutput, error) {
if params == nil {
params = &DeleteParameterGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteParameterGroup", params, optFns, c.addOperationDeleteParameterGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteParameterGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteParameterGroupInput struct {
// The name of the parameter group to delete.
//
// This member is required.
ParameterGroupName *string
noSmithyDocumentSerde
}
type DeleteParameterGroupOutput struct {
// The parameter group that has been deleted.
ParameterGroup *types.ParameterGroup
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteParameterGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteParameterGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteParameterGroup{}, 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 = addOpDeleteParameterGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteParameterGroup(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_opDeleteParameterGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "DeleteParameterGroup",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an existing snapshot. When you receive a successful response from this
// operation, MemoryDB immediately begins deleting the snapshot; you cannot cancel
// or revert this operation.
func (c *Client) DeleteSnapshot(ctx context.Context, params *DeleteSnapshotInput, optFns ...func(*Options)) (*DeleteSnapshotOutput, error) {
if params == nil {
params = &DeleteSnapshotInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteSnapshot", params, optFns, c.addOperationDeleteSnapshotMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteSnapshotOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteSnapshotInput struct {
// The name of the snapshot to delete
//
// This member is required.
SnapshotName *string
noSmithyDocumentSerde
}
type DeleteSnapshotOutput struct {
// The snapshot object that has been deleted.
Snapshot *types.Snapshot
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteSnapshotMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteSnapshot{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteSnapshot{}, 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 = addOpDeleteSnapshotValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteSnapshot(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_opDeleteSnapshot(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "DeleteSnapshot",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a subnet group. You cannot delete a default subnet group or one that is
// associated with any clusters.
func (c *Client) DeleteSubnetGroup(ctx context.Context, params *DeleteSubnetGroupInput, optFns ...func(*Options)) (*DeleteSubnetGroupOutput, error) {
if params == nil {
params = &DeleteSubnetGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteSubnetGroup", params, optFns, c.addOperationDeleteSubnetGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteSubnetGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteSubnetGroupInput struct {
// The name of the subnet group to delete
//
// This member is required.
SubnetGroupName *string
noSmithyDocumentSerde
}
type DeleteSubnetGroupOutput struct {
// The subnet group object that has been deleted.
SubnetGroup *types.SubnetGroup
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteSubnetGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteSubnetGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteSubnetGroup{}, 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 = addOpDeleteSubnetGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteSubnetGroup(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_opDeleteSubnetGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "DeleteSubnetGroup",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a user. The user will be removed from all ACLs and in turn removed from
// all clusters.
func (c *Client) DeleteUser(ctx context.Context, params *DeleteUserInput, optFns ...func(*Options)) (*DeleteUserOutput, error) {
if params == nil {
params = &DeleteUserInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteUser", params, optFns, c.addOperationDeleteUserMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteUserOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteUserInput struct {
// The name of the user to delete
//
// This member is required.
UserName *string
noSmithyDocumentSerde
}
type DeleteUserOutput struct {
// The user object that has been deleted.
User *types.User
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteUserMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteUser{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteUser{}, 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 = addOpDeleteUserValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteUser(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_opDeleteUser(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "DeleteUser",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of ACLs
func (c *Client) DescribeACLs(ctx context.Context, params *DescribeACLsInput, optFns ...func(*Options)) (*DescribeACLsOutput, error) {
if params == nil {
params = &DescribeACLsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeACLs", params, optFns, c.addOperationDescribeACLsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeACLsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeACLsInput struct {
// The name of the ACL
ACLName *string
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
MaxResults *int32
// An optional argument to pass in case the total number of records exceeds the
// value of MaxResults. If nextToken is returned, there are more results available.
// The value of nextToken is a unique pagination token for each page. Make the call
// again using the returned token to retrieve the next page. Keep all other
// arguments unchanged.
NextToken *string
noSmithyDocumentSerde
}
type DescribeACLsOutput struct {
// The list of ACLs
ACLs []types.ACL
// If nextToken is returned, there are more results available. The value of
// nextToken is a unique pagination token for each page. Make the call again using
// the returned token to retrieve the next page. Keep all other arguments
// unchanged.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeACLsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeACLs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeACLs{}, 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_opDescribeACLs(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
}
// DescribeACLsAPIClient is a client that implements the DescribeACLs operation.
type DescribeACLsAPIClient interface {
DescribeACLs(context.Context, *DescribeACLsInput, ...func(*Options)) (*DescribeACLsOutput, error)
}
var _ DescribeACLsAPIClient = (*Client)(nil)
// DescribeACLsPaginatorOptions is the paginator options for DescribeACLs
type DescribeACLsPaginatorOptions struct {
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
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
}
// DescribeACLsPaginator is a paginator for DescribeACLs
type DescribeACLsPaginator struct {
options DescribeACLsPaginatorOptions
client DescribeACLsAPIClient
params *DescribeACLsInput
nextToken *string
firstPage bool
}
// NewDescribeACLsPaginator returns a new DescribeACLsPaginator
func NewDescribeACLsPaginator(client DescribeACLsAPIClient, params *DescribeACLsInput, optFns ...func(*DescribeACLsPaginatorOptions)) *DescribeACLsPaginator {
if params == nil {
params = &DescribeACLsInput{}
}
options := DescribeACLsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeACLsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeACLsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeACLs page.
func (p *DescribeACLsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeACLsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.DescribeACLs(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_opDescribeACLs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "DescribeACLs",
}
}
| 230 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about all provisioned clusters if no cluster identifier is
// specified, or about a specific cluster if a cluster name is supplied.
func (c *Client) DescribeClusters(ctx context.Context, params *DescribeClustersInput, optFns ...func(*Options)) (*DescribeClustersOutput, error) {
if params == nil {
params = &DescribeClustersInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeClusters", params, optFns, c.addOperationDescribeClustersMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeClustersOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeClustersInput struct {
// The name of the cluster
ClusterName *string
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
MaxResults *int32
// An optional argument to pass in case the total number of records exceeds the
// value of MaxResults. If nextToken is returned, there are more results available.
// The value of nextToken is a unique pagination token for each page. Make the call
// again using the returned token to retrieve the next page. Keep all other
// arguments unchanged.
NextToken *string
// An optional flag that can be included in the request to retrieve information
// about the individual shard(s).
ShowShardDetails *bool
noSmithyDocumentSerde
}
type DescribeClustersOutput struct {
// A list of clusters
Clusters []types.Cluster
// An optional argument to pass in case the total number of records exceeds the
// value of MaxResults. If nextToken is returned, there are more results available.
// The value of nextToken is a unique pagination token for each page. Make the call
// again using the returned token to retrieve the next page. Keep all other
// arguments unchanged.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeClustersMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeClusters{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeClusters{}, 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_opDescribeClusters(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
}
// DescribeClustersAPIClient is a client that implements the DescribeClusters
// operation.
type DescribeClustersAPIClient interface {
DescribeClusters(context.Context, *DescribeClustersInput, ...func(*Options)) (*DescribeClustersOutput, error)
}
var _ DescribeClustersAPIClient = (*Client)(nil)
// DescribeClustersPaginatorOptions is the paginator options for DescribeClusters
type DescribeClustersPaginatorOptions struct {
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
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
}
// DescribeClustersPaginator is a paginator for DescribeClusters
type DescribeClustersPaginator struct {
options DescribeClustersPaginatorOptions
client DescribeClustersAPIClient
params *DescribeClustersInput
nextToken *string
firstPage bool
}
// NewDescribeClustersPaginator returns a new DescribeClustersPaginator
func NewDescribeClustersPaginator(client DescribeClustersAPIClient, params *DescribeClustersInput, optFns ...func(*DescribeClustersPaginatorOptions)) *DescribeClustersPaginator {
if params == nil {
params = &DescribeClustersInput{}
}
options := DescribeClustersPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeClustersPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeClustersPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeClusters page.
func (p *DescribeClustersPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeClustersOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.DescribeClusters(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_opDescribeClusters(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "DescribeClusters",
}
}
| 237 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of the available Redis engine versions.
func (c *Client) DescribeEngineVersions(ctx context.Context, params *DescribeEngineVersionsInput, optFns ...func(*Options)) (*DescribeEngineVersionsOutput, error) {
if params == nil {
params = &DescribeEngineVersionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeEngineVersions", params, optFns, c.addOperationDescribeEngineVersionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeEngineVersionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeEngineVersionsInput struct {
// If true, specifies that only the default version of the specified engine or
// engine and major version combination is to be returned.
DefaultOnly bool
// The Redis engine version
EngineVersion *string
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
MaxResults *int32
// An optional argument to pass in case the total number of records exceeds the
// value of MaxResults. If nextToken is returned, there are more results available.
// The value of nextToken is a unique pagination token for each page. Make the call
// again using the returned token to retrieve the next page. Keep all other
// arguments unchanged.
NextToken *string
// The name of a specific parameter group family to return details for.
ParameterGroupFamily *string
noSmithyDocumentSerde
}
type DescribeEngineVersionsOutput struct {
// A list of engine version details. Each element in the list contains detailed
// information about one engine version.
EngineVersions []types.EngineVersionInfo
// An optional argument to pass in case the total number of records exceeds the
// value of MaxResults. If nextToken is returned, there are more results available.
// The value of nextToken is a unique pagination token for each page. Make the call
// again using the returned token to retrieve the next page. Keep all other
// arguments unchanged.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeEngineVersionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeEngineVersions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeEngineVersions{}, 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_opDescribeEngineVersions(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
}
// DescribeEngineVersionsAPIClient is a client that implements the
// DescribeEngineVersions operation.
type DescribeEngineVersionsAPIClient interface {
DescribeEngineVersions(context.Context, *DescribeEngineVersionsInput, ...func(*Options)) (*DescribeEngineVersionsOutput, error)
}
var _ DescribeEngineVersionsAPIClient = (*Client)(nil)
// DescribeEngineVersionsPaginatorOptions is the paginator options for
// DescribeEngineVersions
type DescribeEngineVersionsPaginatorOptions struct {
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
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
}
// DescribeEngineVersionsPaginator is a paginator for DescribeEngineVersions
type DescribeEngineVersionsPaginator struct {
options DescribeEngineVersionsPaginatorOptions
client DescribeEngineVersionsAPIClient
params *DescribeEngineVersionsInput
nextToken *string
firstPage bool
}
// NewDescribeEngineVersionsPaginator returns a new DescribeEngineVersionsPaginator
func NewDescribeEngineVersionsPaginator(client DescribeEngineVersionsAPIClient, params *DescribeEngineVersionsInput, optFns ...func(*DescribeEngineVersionsPaginatorOptions)) *DescribeEngineVersionsPaginator {
if params == nil {
params = &DescribeEngineVersionsInput{}
}
options := DescribeEngineVersionsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeEngineVersionsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeEngineVersionsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeEngineVersions page.
func (p *DescribeEngineVersionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeEngineVersionsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.DescribeEngineVersions(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_opDescribeEngineVersions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "DescribeEngineVersions",
}
}
| 241 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Returns events related to clusters, security groups, and parameter groups. You
// can obtain events specific to a particular cluster, security group, or parameter
// group by providing the name as a parameter. By default, only the events
// occurring within the last hour are returned; however, you can retrieve up to 14
// days' worth of events if necessary.
func (c *Client) DescribeEvents(ctx context.Context, params *DescribeEventsInput, optFns ...func(*Options)) (*DescribeEventsOutput, error) {
if params == nil {
params = &DescribeEventsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeEvents", params, optFns, c.addOperationDescribeEventsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeEventsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeEventsInput struct {
// The number of minutes worth of events to retrieve.
Duration *int32
// The end of the time interval for which to retrieve events, specified in ISO
// 8601 format. Example: 2017-03-30T07:03:49.555Z
EndTime *time.Time
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
MaxResults *int32
// An optional argument to pass in case the total number of records exceeds the
// value of MaxResults. If nextToken is returned, there are more results available.
// The value of nextToken is a unique pagination token for each page. Make the call
// again using the returned token to retrieve the next page. Keep all other
// arguments unchanged.
NextToken *string
// The identifier of the event source for which events are returned. If not
// specified, all sources are included in the response.
SourceName *string
// The event source to retrieve events for. If no value is specified, all events
// are returned.
SourceType types.SourceType
// The beginning of the time interval to retrieve events for, specified in ISO
// 8601 format. Example: 2017-03-30T07:03:49.555Z
StartTime *time.Time
noSmithyDocumentSerde
}
type DescribeEventsOutput struct {
// A list of events. Each element in the list contains detailed information about
// one event.
Events []types.Event
// An optional argument to pass in case the total number of records exceeds the
// value of MaxResults. If nextToken is returned, there are more results available.
// The value of nextToken is a unique pagination token for each page. Make the call
// again using the returned token to retrieve the next page. Keep all other
// arguments unchanged.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeEventsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeEvents{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeEvents{}, 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_opDescribeEvents(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
}
// DescribeEventsAPIClient is a client that implements the DescribeEvents
// operation.
type DescribeEventsAPIClient interface {
DescribeEvents(context.Context, *DescribeEventsInput, ...func(*Options)) (*DescribeEventsOutput, error)
}
var _ DescribeEventsAPIClient = (*Client)(nil)
// DescribeEventsPaginatorOptions is the paginator options for DescribeEvents
type DescribeEventsPaginatorOptions struct {
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
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
}
// DescribeEventsPaginator is a paginator for DescribeEvents
type DescribeEventsPaginator struct {
options DescribeEventsPaginatorOptions
client DescribeEventsAPIClient
params *DescribeEventsInput
nextToken *string
firstPage bool
}
// NewDescribeEventsPaginator returns a new DescribeEventsPaginator
func NewDescribeEventsPaginator(client DescribeEventsAPIClient, params *DescribeEventsInput, optFns ...func(*DescribeEventsPaginatorOptions)) *DescribeEventsPaginator {
if params == nil {
params = &DescribeEventsInput{}
}
options := DescribeEventsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeEventsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeEventsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeEvents page.
func (p *DescribeEventsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeEventsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.DescribeEvents(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_opDescribeEvents(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "DescribeEvents",
}
}
| 254 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of parameter group descriptions. If a parameter group name is
// specified, the list contains only the descriptions for that group.
func (c *Client) DescribeParameterGroups(ctx context.Context, params *DescribeParameterGroupsInput, optFns ...func(*Options)) (*DescribeParameterGroupsOutput, error) {
if params == nil {
params = &DescribeParameterGroupsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeParameterGroups", params, optFns, c.addOperationDescribeParameterGroupsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeParameterGroupsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeParameterGroupsInput struct {
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
MaxResults *int32
// An optional argument to pass in case the total number of records exceeds the
// value of MaxResults. If nextToken is returned, there are more results available.
// The value of nextToken is a unique pagination token for each page. Make the call
// again using the returned token to retrieve the next page. Keep all other
// arguments unchanged.
NextToken *string
// The name of a specific parameter group to return details for.
ParameterGroupName *string
noSmithyDocumentSerde
}
type DescribeParameterGroupsOutput struct {
// An optional argument to pass in case the total number of records exceeds the
// value of MaxResults. If nextToken is returned, there are more results available.
// The value of nextToken is a unique pagination token for each page. Make the call
// again using the returned token to retrieve the next page. Keep all other
// arguments unchanged.
NextToken *string
// A list of parameter groups. Each element in the list contains detailed
// information about one parameter group.
ParameterGroups []types.ParameterGroup
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeParameterGroupsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeParameterGroups{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeParameterGroups{}, 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_opDescribeParameterGroups(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
}
// DescribeParameterGroupsAPIClient is a client that implements the
// DescribeParameterGroups operation.
type DescribeParameterGroupsAPIClient interface {
DescribeParameterGroups(context.Context, *DescribeParameterGroupsInput, ...func(*Options)) (*DescribeParameterGroupsOutput, error)
}
var _ DescribeParameterGroupsAPIClient = (*Client)(nil)
// DescribeParameterGroupsPaginatorOptions is the paginator options for
// DescribeParameterGroups
type DescribeParameterGroupsPaginatorOptions struct {
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
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
}
// DescribeParameterGroupsPaginator is a paginator for DescribeParameterGroups
type DescribeParameterGroupsPaginator struct {
options DescribeParameterGroupsPaginatorOptions
client DescribeParameterGroupsAPIClient
params *DescribeParameterGroupsInput
nextToken *string
firstPage bool
}
// NewDescribeParameterGroupsPaginator returns a new
// DescribeParameterGroupsPaginator
func NewDescribeParameterGroupsPaginator(client DescribeParameterGroupsAPIClient, params *DescribeParameterGroupsInput, optFns ...func(*DescribeParameterGroupsPaginatorOptions)) *DescribeParameterGroupsPaginator {
if params == nil {
params = &DescribeParameterGroupsInput{}
}
options := DescribeParameterGroupsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeParameterGroupsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeParameterGroupsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeParameterGroups page.
func (p *DescribeParameterGroupsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeParameterGroupsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.DescribeParameterGroups(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_opDescribeParameterGroups(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "DescribeParameterGroups",
}
}
| 236 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns the detailed parameter list for a particular parameter group.
func (c *Client) DescribeParameters(ctx context.Context, params *DescribeParametersInput, optFns ...func(*Options)) (*DescribeParametersOutput, error) {
if params == nil {
params = &DescribeParametersInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeParameters", params, optFns, c.addOperationDescribeParametersMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeParametersOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeParametersInput struct {
// he name of a specific parameter group to return details for.
//
// This member is required.
ParameterGroupName *string
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
MaxResults *int32
// An optional argument to pass in case the total number of records exceeds the
// value of MaxResults. If nextToken is returned, there are more results available.
// The value of nextToken is a unique pagination token for each page. Make the call
// again using the returned token to retrieve the next page. Keep all other
// arguments unchanged.
NextToken *string
noSmithyDocumentSerde
}
type DescribeParametersOutput struct {
// An optional argument to pass in case the total number of records exceeds the
// value of MaxResults. If nextToken is returned, there are more results available.
// The value of nextToken is a unique pagination token for each page. Make the call
// again using the returned token to retrieve the next page. Keep all other
// arguments unchanged.
NextToken *string
// A list of parameters specific to a particular parameter group. Each element in
// the list contains detailed information about one parameter.
Parameters []types.Parameter
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeParametersMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeParameters{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeParameters{}, 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 = addOpDescribeParametersValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeParameters(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
}
// DescribeParametersAPIClient is a client that implements the DescribeParameters
// operation.
type DescribeParametersAPIClient interface {
DescribeParameters(context.Context, *DescribeParametersInput, ...func(*Options)) (*DescribeParametersOutput, error)
}
var _ DescribeParametersAPIClient = (*Client)(nil)
// DescribeParametersPaginatorOptions is the paginator options for
// DescribeParameters
type DescribeParametersPaginatorOptions struct {
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
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
}
// DescribeParametersPaginator is a paginator for DescribeParameters
type DescribeParametersPaginator struct {
options DescribeParametersPaginatorOptions
client DescribeParametersAPIClient
params *DescribeParametersInput
nextToken *string
firstPage bool
}
// NewDescribeParametersPaginator returns a new DescribeParametersPaginator
func NewDescribeParametersPaginator(client DescribeParametersAPIClient, params *DescribeParametersInput, optFns ...func(*DescribeParametersPaginatorOptions)) *DescribeParametersPaginator {
if params == nil {
params = &DescribeParametersInput{}
}
options := DescribeParametersPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeParametersPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeParametersPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeParameters page.
func (p *DescribeParametersPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeParametersOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.DescribeParameters(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_opDescribeParameters(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "DescribeParameters",
}
}
| 239 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about reserved nodes for this account, or about a specified
// reserved node.
func (c *Client) DescribeReservedNodes(ctx context.Context, params *DescribeReservedNodesInput, optFns ...func(*Options)) (*DescribeReservedNodesOutput, error) {
if params == nil {
params = &DescribeReservedNodesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeReservedNodes", params, optFns, c.addOperationDescribeReservedNodesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeReservedNodesOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeReservedNodesInput struct {
// The duration filter value, specified in years or seconds. Use this parameter to
// show only reservations for this duration.
Duration *string
// The maximum number of records to include in the response. If more records exist
// than the specified MaxRecords value, a marker is included in the response so
// that the remaining results can be retrieved.
MaxResults *int32
// An optional marker returned from a prior request. Use this marker for
// pagination of results from this operation. If this parameter is specified, the
// response includes only records beyond the marker, up to the value specified by
// MaxRecords.
NextToken *string
// The node type filter value. Use this parameter to show only those reservations
// matching the specified node type. For more information, see Supported node types (https://docs.aws.amazon.com/memorydb/latest/devguide/nodes.reserved.html#reserved-nodes-supported)
// .
NodeType *string
// The offering type filter value. Use this parameter to show only the available
// offerings matching the specified offering type. Valid values: "All
// Upfront"|"Partial Upfront"| "No Upfront"
OfferingType *string
// The reserved node identifier filter value. Use this parameter to show only the
// reservation that matches the specified reservation ID.
ReservationId *string
// The offering identifier filter value. Use this parameter to show only purchased
// reservations matching the specified offering identifier.
ReservedNodesOfferingId *string
noSmithyDocumentSerde
}
type DescribeReservedNodesOutput struct {
// An optional marker returned from a prior request. Use this marker for
// pagination of results from this operation. If this parameter is specified, the
// response includes only records beyond the marker, up to the value specified by
// MaxRecords.
NextToken *string
// Returns information about reserved nodes for this account, or about a specified
// reserved node.
ReservedNodes []types.ReservedNode
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeReservedNodesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeReservedNodes{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeReservedNodes{}, 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_opDescribeReservedNodes(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
}
// DescribeReservedNodesAPIClient is a client that implements the
// DescribeReservedNodes operation.
type DescribeReservedNodesAPIClient interface {
DescribeReservedNodes(context.Context, *DescribeReservedNodesInput, ...func(*Options)) (*DescribeReservedNodesOutput, error)
}
var _ DescribeReservedNodesAPIClient = (*Client)(nil)
// DescribeReservedNodesPaginatorOptions is the paginator options for
// DescribeReservedNodes
type DescribeReservedNodesPaginatorOptions struct {
// The maximum number of records to include in the response. If more records exist
// than the specified MaxRecords value, a marker is included in the response so
// that the remaining results can be retrieved.
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
}
// DescribeReservedNodesPaginator is a paginator for DescribeReservedNodes
type DescribeReservedNodesPaginator struct {
options DescribeReservedNodesPaginatorOptions
client DescribeReservedNodesAPIClient
params *DescribeReservedNodesInput
nextToken *string
firstPage bool
}
// NewDescribeReservedNodesPaginator returns a new DescribeReservedNodesPaginator
func NewDescribeReservedNodesPaginator(client DescribeReservedNodesAPIClient, params *DescribeReservedNodesInput, optFns ...func(*DescribeReservedNodesPaginatorOptions)) *DescribeReservedNodesPaginator {
if params == nil {
params = &DescribeReservedNodesInput{}
}
options := DescribeReservedNodesPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeReservedNodesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeReservedNodesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeReservedNodes page.
func (p *DescribeReservedNodesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeReservedNodesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.DescribeReservedNodes(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_opDescribeReservedNodes(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "DescribeReservedNodes",
}
}
| 252 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists available reserved node offerings.
func (c *Client) DescribeReservedNodesOfferings(ctx context.Context, params *DescribeReservedNodesOfferingsInput, optFns ...func(*Options)) (*DescribeReservedNodesOfferingsOutput, error) {
if params == nil {
params = &DescribeReservedNodesOfferingsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeReservedNodesOfferings", params, optFns, c.addOperationDescribeReservedNodesOfferingsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeReservedNodesOfferingsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeReservedNodesOfferingsInput struct {
// Duration filter value, specified in years or seconds. Use this parameter to
// show only reservations for a given duration.
Duration *string
// The maximum number of records to include in the response. If more records exist
// than the specified MaxRecords value, a marker is included in the response so
// that the remaining results can be retrieved.
MaxResults *int32
// An optional marker returned from a prior request. Use this marker for
// pagination of results from this operation. If this parameter is specified, the
// response includes only records beyond the marker, up to the value specified by
// MaxRecords.
NextToken *string
// The node type for the reserved nodes. For more information, see Supported node
// types (https://docs.aws.amazon.com/memorydb/latest/devguide/nodes.reserved.html#reserved-nodes-supported)
// .
NodeType *string
// The offering type filter value. Use this parameter to show only the available
// offerings matching the specified offering type. Valid values: "All
// Upfront"|"Partial Upfront"| "No Upfront"
OfferingType *string
// The offering identifier filter value. Use this parameter to show only the
// available offering that matches the specified reservation identifier.
ReservedNodesOfferingId *string
noSmithyDocumentSerde
}
type DescribeReservedNodesOfferingsOutput struct {
// An optional marker returned from a prior request. Use this marker for
// pagination of results from this operation. If this parameter is specified, the
// response includes only records beyond the marker, up to the value specified by
// MaxRecords.
NextToken *string
// Lists available reserved node offerings.
ReservedNodesOfferings []types.ReservedNodesOffering
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeReservedNodesOfferingsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeReservedNodesOfferings{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeReservedNodesOfferings{}, 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_opDescribeReservedNodesOfferings(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
}
// DescribeReservedNodesOfferingsAPIClient is a client that implements the
// DescribeReservedNodesOfferings operation.
type DescribeReservedNodesOfferingsAPIClient interface {
DescribeReservedNodesOfferings(context.Context, *DescribeReservedNodesOfferingsInput, ...func(*Options)) (*DescribeReservedNodesOfferingsOutput, error)
}
var _ DescribeReservedNodesOfferingsAPIClient = (*Client)(nil)
// DescribeReservedNodesOfferingsPaginatorOptions is the paginator options for
// DescribeReservedNodesOfferings
type DescribeReservedNodesOfferingsPaginatorOptions struct {
// The maximum number of records to include in the response. If more records exist
// than the specified MaxRecords value, a marker is included in the response so
// that the remaining results can be retrieved.
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
}
// DescribeReservedNodesOfferingsPaginator is a paginator for
// DescribeReservedNodesOfferings
type DescribeReservedNodesOfferingsPaginator struct {
options DescribeReservedNodesOfferingsPaginatorOptions
client DescribeReservedNodesOfferingsAPIClient
params *DescribeReservedNodesOfferingsInput
nextToken *string
firstPage bool
}
// NewDescribeReservedNodesOfferingsPaginator returns a new
// DescribeReservedNodesOfferingsPaginator
func NewDescribeReservedNodesOfferingsPaginator(client DescribeReservedNodesOfferingsAPIClient, params *DescribeReservedNodesOfferingsInput, optFns ...func(*DescribeReservedNodesOfferingsPaginatorOptions)) *DescribeReservedNodesOfferingsPaginator {
if params == nil {
params = &DescribeReservedNodesOfferingsInput{}
}
options := DescribeReservedNodesOfferingsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeReservedNodesOfferingsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeReservedNodesOfferingsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeReservedNodesOfferings page.
func (p *DescribeReservedNodesOfferingsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeReservedNodesOfferingsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.DescribeReservedNodesOfferings(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_opDescribeReservedNodesOfferings(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "DescribeReservedNodesOfferings",
}
}
| 248 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns details of the service updates
func (c *Client) DescribeServiceUpdates(ctx context.Context, params *DescribeServiceUpdatesInput, optFns ...func(*Options)) (*DescribeServiceUpdatesOutput, error) {
if params == nil {
params = &DescribeServiceUpdatesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeServiceUpdates", params, optFns, c.addOperationDescribeServiceUpdatesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeServiceUpdatesOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeServiceUpdatesInput struct {
// The list of cluster names to identify service updates to apply
ClusterNames []string
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
MaxResults *int32
// An optional argument to pass in case the total number of records exceeds the
// value of MaxResults. If nextToken is returned, there are more results available.
// The value of nextToken is a unique pagination token for each page. Make the call
// again using the returned token to retrieve the next page. Keep all other
// arguments unchanged.
NextToken *string
// The unique ID of the service update to describe.
ServiceUpdateName *string
// The status(es) of the service updates to filter on
Status []types.ServiceUpdateStatus
noSmithyDocumentSerde
}
type DescribeServiceUpdatesOutput struct {
// An optional argument to pass in case the total number of records exceeds the
// value of MaxResults. If nextToken is returned, there are more results available.
// The value of nextToken is a unique pagination token for each page. Make the call
// again using the returned token to retrieve the next page. Keep all other
// arguments unchanged.
NextToken *string
// A list of service updates
ServiceUpdates []types.ServiceUpdate
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeServiceUpdatesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeServiceUpdates{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeServiceUpdates{}, 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_opDescribeServiceUpdates(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
}
// DescribeServiceUpdatesAPIClient is a client that implements the
// DescribeServiceUpdates operation.
type DescribeServiceUpdatesAPIClient interface {
DescribeServiceUpdates(context.Context, *DescribeServiceUpdatesInput, ...func(*Options)) (*DescribeServiceUpdatesOutput, error)
}
var _ DescribeServiceUpdatesAPIClient = (*Client)(nil)
// DescribeServiceUpdatesPaginatorOptions is the paginator options for
// DescribeServiceUpdates
type DescribeServiceUpdatesPaginatorOptions struct {
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
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
}
// DescribeServiceUpdatesPaginator is a paginator for DescribeServiceUpdates
type DescribeServiceUpdatesPaginator struct {
options DescribeServiceUpdatesPaginatorOptions
client DescribeServiceUpdatesAPIClient
params *DescribeServiceUpdatesInput
nextToken *string
firstPage bool
}
// NewDescribeServiceUpdatesPaginator returns a new DescribeServiceUpdatesPaginator
func NewDescribeServiceUpdatesPaginator(client DescribeServiceUpdatesAPIClient, params *DescribeServiceUpdatesInput, optFns ...func(*DescribeServiceUpdatesPaginatorOptions)) *DescribeServiceUpdatesPaginator {
if params == nil {
params = &DescribeServiceUpdatesInput{}
}
options := DescribeServiceUpdatesPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeServiceUpdatesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeServiceUpdatesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeServiceUpdates page.
func (p *DescribeServiceUpdatesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeServiceUpdatesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.DescribeServiceUpdates(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_opDescribeServiceUpdates(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "DescribeServiceUpdates",
}
}
| 239 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about cluster snapshots. By default, DescribeSnapshots
// lists all of your snapshots; it can optionally describe a single snapshot, or
// just the snapshots associated with a particular cluster.
func (c *Client) DescribeSnapshots(ctx context.Context, params *DescribeSnapshotsInput, optFns ...func(*Options)) (*DescribeSnapshotsOutput, error) {
if params == nil {
params = &DescribeSnapshotsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeSnapshots", params, optFns, c.addOperationDescribeSnapshotsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeSnapshotsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeSnapshotsInput struct {
// A user-supplied cluster identifier. If this parameter is specified, only
// snapshots associated with that specific cluster are described.
ClusterName *string
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
MaxResults *int32
// An optional argument to pass in case the total number of records exceeds the
// value of MaxResults. If nextToken is returned, there are more results available.
// The value of nextToken is a unique pagination token for each page. Make the call
// again using the returned token to retrieve the next page. Keep all other
// arguments unchanged.
NextToken *string
// A Boolean value which if true, the shard configuration is included in the
// snapshot description.
ShowDetail *bool
// A user-supplied name of the snapshot. If this parameter is specified, only this
// named snapshot is described.
SnapshotName *string
// If set to system, the output shows snapshots that were automatically created by
// MemoryDB. If set to user the output shows snapshots that were manually created.
// If omitted, the output shows both automatically and manually created snapshots.
Source *string
noSmithyDocumentSerde
}
type DescribeSnapshotsOutput struct {
// An optional argument to pass in case the total number of records exceeds the
// value of MaxResults. If nextToken is returned, there are more results available.
// The value of nextToken is a unique pagination token for each page. Make the call
// again using the returned token to retrieve the next page. Keep all other
// arguments unchanged.
NextToken *string
// A list of snapshots. Each item in the list contains detailed information about
// one snapshot.
Snapshots []types.Snapshot
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeSnapshotsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeSnapshots{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeSnapshots{}, 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_opDescribeSnapshots(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
}
// DescribeSnapshotsAPIClient is a client that implements the DescribeSnapshots
// operation.
type DescribeSnapshotsAPIClient interface {
DescribeSnapshots(context.Context, *DescribeSnapshotsInput, ...func(*Options)) (*DescribeSnapshotsOutput, error)
}
var _ DescribeSnapshotsAPIClient = (*Client)(nil)
// DescribeSnapshotsPaginatorOptions is the paginator options for DescribeSnapshots
type DescribeSnapshotsPaginatorOptions struct {
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
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
}
// DescribeSnapshotsPaginator is a paginator for DescribeSnapshots
type DescribeSnapshotsPaginator struct {
options DescribeSnapshotsPaginatorOptions
client DescribeSnapshotsAPIClient
params *DescribeSnapshotsInput
nextToken *string
firstPage bool
}
// NewDescribeSnapshotsPaginator returns a new DescribeSnapshotsPaginator
func NewDescribeSnapshotsPaginator(client DescribeSnapshotsAPIClient, params *DescribeSnapshotsInput, optFns ...func(*DescribeSnapshotsPaginatorOptions)) *DescribeSnapshotsPaginator {
if params == nil {
params = &DescribeSnapshotsInput{}
}
options := DescribeSnapshotsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeSnapshotsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeSnapshotsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeSnapshots page.
func (p *DescribeSnapshotsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeSnapshotsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.DescribeSnapshots(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_opDescribeSnapshots(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "DescribeSnapshots",
}
}
| 249 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of subnet group descriptions. If a subnet group name is
// specified, the list contains only the description of that group.
func (c *Client) DescribeSubnetGroups(ctx context.Context, params *DescribeSubnetGroupsInput, optFns ...func(*Options)) (*DescribeSubnetGroupsOutput, error) {
if params == nil {
params = &DescribeSubnetGroupsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeSubnetGroups", params, optFns, c.addOperationDescribeSubnetGroupsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeSubnetGroupsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeSubnetGroupsInput struct {
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
MaxResults *int32
// An optional argument to pass in case the total number of records exceeds the
// value of MaxResults. If nextToken is returned, there are more results available.
// The value of nextToken is a unique pagination token for each page. Make the call
// again using the returned token to retrieve the next page. Keep all other
// arguments unchanged.
NextToken *string
// The name of the subnet group to return details for.
SubnetGroupName *string
noSmithyDocumentSerde
}
type DescribeSubnetGroupsOutput struct {
// An optional argument to pass in case the total number of records exceeds the
// value of MaxResults. If nextToken is returned, there are more results available.
// The value of nextToken is a unique pagination token for each page. Make the call
// again using the returned token to retrieve the next page. Keep all other
// arguments unchanged.
NextToken *string
// A list of subnet groups. Each element in the list contains detailed information
// about one group.
SubnetGroups []types.SubnetGroup
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeSubnetGroupsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeSubnetGroups{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeSubnetGroups{}, 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_opDescribeSubnetGroups(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
}
// DescribeSubnetGroupsAPIClient is a client that implements the
// DescribeSubnetGroups operation.
type DescribeSubnetGroupsAPIClient interface {
DescribeSubnetGroups(context.Context, *DescribeSubnetGroupsInput, ...func(*Options)) (*DescribeSubnetGroupsOutput, error)
}
var _ DescribeSubnetGroupsAPIClient = (*Client)(nil)
// DescribeSubnetGroupsPaginatorOptions is the paginator options for
// DescribeSubnetGroups
type DescribeSubnetGroupsPaginatorOptions struct {
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
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
}
// DescribeSubnetGroupsPaginator is a paginator for DescribeSubnetGroups
type DescribeSubnetGroupsPaginator struct {
options DescribeSubnetGroupsPaginatorOptions
client DescribeSubnetGroupsAPIClient
params *DescribeSubnetGroupsInput
nextToken *string
firstPage bool
}
// NewDescribeSubnetGroupsPaginator returns a new DescribeSubnetGroupsPaginator
func NewDescribeSubnetGroupsPaginator(client DescribeSubnetGroupsAPIClient, params *DescribeSubnetGroupsInput, optFns ...func(*DescribeSubnetGroupsPaginatorOptions)) *DescribeSubnetGroupsPaginator {
if params == nil {
params = &DescribeSubnetGroupsInput{}
}
options := DescribeSubnetGroupsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeSubnetGroupsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeSubnetGroupsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeSubnetGroups page.
func (p *DescribeSubnetGroupsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeSubnetGroupsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.DescribeSubnetGroups(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_opDescribeSubnetGroups(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "DescribeSubnetGroups",
}
}
| 235 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of users.
func (c *Client) DescribeUsers(ctx context.Context, params *DescribeUsersInput, optFns ...func(*Options)) (*DescribeUsersOutput, error) {
if params == nil {
params = &DescribeUsersInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeUsers", params, optFns, c.addOperationDescribeUsersMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeUsersOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeUsersInput struct {
// Filter to determine the list of users to return.
Filters []types.Filter
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
MaxResults *int32
// An optional argument to pass in case the total number of records exceeds the
// value of MaxResults. If nextToken is returned, there are more results available.
// The value of nextToken is a unique pagination token for each page. Make the call
// again using the returned token to retrieve the next page. Keep all other
// arguments unchanged.
NextToken *string
// The name of the user
UserName *string
noSmithyDocumentSerde
}
type DescribeUsersOutput struct {
// An optional argument to pass in case the total number of records exceeds the
// value of MaxResults. If nextToken is returned, there are more results available.
// The value of nextToken is a unique pagination token for each page. Make the call
// again using the returned token to retrieve the next page. Keep all other
// arguments unchanged.
NextToken *string
// A list of users.
Users []types.User
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeUsersMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeUsers{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeUsers{}, 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 = addOpDescribeUsersValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeUsers(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
}
// DescribeUsersAPIClient is a client that implements the DescribeUsers operation.
type DescribeUsersAPIClient interface {
DescribeUsers(context.Context, *DescribeUsersInput, ...func(*Options)) (*DescribeUsersOutput, error)
}
var _ DescribeUsersAPIClient = (*Client)(nil)
// DescribeUsersPaginatorOptions is the paginator options for DescribeUsers
type DescribeUsersPaginatorOptions struct {
// The maximum number of records to include in the response. If more records exist
// than the specified MaxResults value, a token is included in the response so that
// the remaining results can be retrieved.
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
}
// DescribeUsersPaginator is a paginator for DescribeUsers
type DescribeUsersPaginator struct {
options DescribeUsersPaginatorOptions
client DescribeUsersAPIClient
params *DescribeUsersInput
nextToken *string
firstPage bool
}
// NewDescribeUsersPaginator returns a new DescribeUsersPaginator
func NewDescribeUsersPaginator(client DescribeUsersAPIClient, params *DescribeUsersInput, optFns ...func(*DescribeUsersPaginatorOptions)) *DescribeUsersPaginator {
if params == nil {
params = &DescribeUsersInput{}
}
options := DescribeUsersPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeUsersPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeUsersPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeUsers page.
func (p *DescribeUsersPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeUsersOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.DescribeUsers(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_opDescribeUsers(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "DescribeUsers",
}
}
| 237 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Used to failover a shard. This API is designed for testing the behavior of your
// application in case of MemoryDB failover. It is not designed to be used as a
// production-level tool for initiating a failover to overcome a problem you may
// have with the cluster. Moreover, in certain conditions such as large scale
// operational events, Amazon may block this API.
func (c *Client) FailoverShard(ctx context.Context, params *FailoverShardInput, optFns ...func(*Options)) (*FailoverShardOutput, error) {
if params == nil {
params = &FailoverShardInput{}
}
result, metadata, err := c.invokeOperation(ctx, "FailoverShard", params, optFns, c.addOperationFailoverShardMiddlewares)
if err != nil {
return nil, err
}
out := result.(*FailoverShardOutput)
out.ResultMetadata = metadata
return out, nil
}
type FailoverShardInput struct {
// The cluster being failed over
//
// This member is required.
ClusterName *string
// The name of the shard
//
// This member is required.
ShardName *string
noSmithyDocumentSerde
}
type FailoverShardOutput struct {
// The cluster being failed over
Cluster *types.Cluster
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationFailoverShardMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpFailoverShard{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpFailoverShard{}, 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 = addOpFailoverShardValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opFailoverShard(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_opFailoverShard(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "FailoverShard",
}
}
| 134 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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 all available node types that you can scale to from your cluster's
// current node type. When you use the UpdateCluster operation to scale your
// cluster, the value of the NodeType parameter must be one of the node types
// returned by this operation.
func (c *Client) ListAllowedNodeTypeUpdates(ctx context.Context, params *ListAllowedNodeTypeUpdatesInput, optFns ...func(*Options)) (*ListAllowedNodeTypeUpdatesOutput, error) {
if params == nil {
params = &ListAllowedNodeTypeUpdatesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListAllowedNodeTypeUpdates", params, optFns, c.addOperationListAllowedNodeTypeUpdatesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListAllowedNodeTypeUpdatesOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListAllowedNodeTypeUpdatesInput struct {
// The name of the cluster you want to scale. MemoryDB uses the cluster name to
// identify the current node type being used by this cluster, and from that to
// create a list of node types you can scale up to.
//
// This member is required.
ClusterName *string
noSmithyDocumentSerde
}
type ListAllowedNodeTypeUpdatesOutput struct {
// A list node types which you can use to scale down your cluster.
ScaleDownNodeTypes []string
// A list node types which you can use to scale up your cluster.
ScaleUpNodeTypes []string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListAllowedNodeTypeUpdatesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListAllowedNodeTypeUpdates{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListAllowedNodeTypeUpdates{}, 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 = addOpListAllowedNodeTypeUpdatesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListAllowedNodeTypeUpdates(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_opListAllowedNodeTypeUpdates(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "ListAllowedNodeTypeUpdates",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all tags currently on a named resource. A tag is a key-value pair where
// the key and value are case-sensitive. You can use tags to categorize and track
// your MemoryDB resources. For more information, see Tagging your MemoryDB
// resources (https://docs.aws.amazon.com/MemoryDB/latest/devguide/Tagging-Resources.html)
func (c *Client) ListTags(ctx context.Context, params *ListTagsInput, optFns ...func(*Options)) (*ListTagsOutput, error) {
if params == nil {
params = &ListTagsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListTags", params, optFns, c.addOperationListTagsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListTagsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListTagsInput struct {
// The Amazon Resource Name (ARN) of the resource for which you want the list of
// tags
//
// This member is required.
ResourceArn *string
noSmithyDocumentSerde
}
type ListTagsOutput struct {
// A list of tags as key-value pairs.
TagList []types.Tag
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListTagsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListTags{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListTags{}, 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 = addOpListTagsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListTags(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_opListTags(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "ListTags",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Allows you to purchase a reserved node offering. Reserved nodes are not
// eligible for cancellation and are non-refundable.
func (c *Client) PurchaseReservedNodesOffering(ctx context.Context, params *PurchaseReservedNodesOfferingInput, optFns ...func(*Options)) (*PurchaseReservedNodesOfferingOutput, error) {
if params == nil {
params = &PurchaseReservedNodesOfferingInput{}
}
result, metadata, err := c.invokeOperation(ctx, "PurchaseReservedNodesOffering", params, optFns, c.addOperationPurchaseReservedNodesOfferingMiddlewares)
if err != nil {
return nil, err
}
out := result.(*PurchaseReservedNodesOfferingOutput)
out.ResultMetadata = metadata
return out, nil
}
type PurchaseReservedNodesOfferingInput struct {
// The ID of the reserved node offering to purchase.
//
// This member is required.
ReservedNodesOfferingId *string
// The number of node instances to reserve.
NodeCount *int32
// A customer-specified identifier to track this reservation.
ReservationId *string
// A list of tags to be added to this resource. A tag is a key-value pair. A tag
// key must be accompanied by a tag value, although null is accepted.
Tags []types.Tag
noSmithyDocumentSerde
}
type PurchaseReservedNodesOfferingOutput struct {
// Represents the output of a PurchaseReservedNodesOffering operation.
ReservedNode *types.ReservedNode
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationPurchaseReservedNodesOfferingMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpPurchaseReservedNodesOffering{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpPurchaseReservedNodesOffering{}, 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 = addOpPurchaseReservedNodesOfferingValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPurchaseReservedNodesOffering(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_opPurchaseReservedNodesOffering(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "PurchaseReservedNodesOffering",
}
}
| 136 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Modifies the parameters of a parameter group to the engine or system default
// value. You can reset specific parameters by submitting a list of parameter
// names. To reset the entire parameter group, specify the AllParameters and
// ParameterGroupName parameters.
func (c *Client) ResetParameterGroup(ctx context.Context, params *ResetParameterGroupInput, optFns ...func(*Options)) (*ResetParameterGroupOutput, error) {
if params == nil {
params = &ResetParameterGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ResetParameterGroup", params, optFns, c.addOperationResetParameterGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ResetParameterGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type ResetParameterGroupInput struct {
// The name of the parameter group to reset.
//
// This member is required.
ParameterGroupName *string
// If true, all parameters in the parameter group are reset to their default
// values. If false, only the parameters listed by ParameterNames are reset to
// their default values.
AllParameters bool
// An array of parameter names to reset to their default values. If AllParameters
// is true, do not use ParameterNames. If AllParameters is false, you must specify
// the name of at least one parameter to reset.
ParameterNames []string
noSmithyDocumentSerde
}
type ResetParameterGroupOutput struct {
// The parameter group being reset.
ParameterGroup *types.ParameterGroup
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationResetParameterGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpResetParameterGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpResetParameterGroup{}, 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 = addOpResetParameterGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opResetParameterGroup(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_opResetParameterGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "ResetParameterGroup",
}
}
| 138 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// A tag is a key-value pair where the key and value are case-sensitive. You can
// use tags to categorize and track all your MemoryDB resources. When you add or
// remove tags on clusters, those actions will be replicated to all nodes in the
// cluster. For more information, see Resource-level permissions (https://docs.aws.amazon.com/MemoryDB/latest/devguide/iam.resourcelevelpermissions.html)
// . For example, you can use cost-allocation tags to your MemoryDB resources,
// Amazon generates a cost allocation report as a comma-separated value (CSV) file
// with your usage and costs aggregated by your tags. You can apply tags that
// represent business categories (such as cost centers, application names, or
// owners) to organize your costs across multiple services. For more information,
// see Using Cost Allocation Tags (https://docs.aws.amazon.com/MemoryDB/latest/devguide/tagging.html)
// .
func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error) {
if params == nil {
params = &TagResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "TagResource", params, optFns, c.addOperationTagResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*TagResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type TagResourceInput struct {
// The Amazon Resource Name (ARN) of the resource to which the tags are to be added
//
// This member is required.
ResourceArn *string
// A list of tags to be added to this resource. A tag is a key-value pair. A tag
// key must be accompanied by a tag value, although null is accepted.
//
// This member is required.
Tags []types.Tag
noSmithyDocumentSerde
}
type TagResourceOutput struct {
// A list of tags as key-value pairs.
TagList []types.Tag
// 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(&awsAwsjson11_serializeOpTagResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_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: "memorydb",
OperationName: "TagResource",
}
}
| 141 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Use this operation to remove tags on a 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 Amazon Resource Name (ARN) of the resource to which the tags are to be
// removed
//
// This member is required.
ResourceArn *string
// The list of keys of the tags that are to be removed
//
// This member is required.
TagKeys []string
noSmithyDocumentSerde
}
type UntagResourceOutput struct {
// The list of tags removed
TagList []types.Tag
// 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(&awsAwsjson11_serializeOpUntagResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_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: "memorydb",
OperationName: "UntagResource",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Changes the list of users that belong to the Access Control List.
func (c *Client) UpdateACL(ctx context.Context, params *UpdateACLInput, optFns ...func(*Options)) (*UpdateACLOutput, error) {
if params == nil {
params = &UpdateACLInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateACL", params, optFns, c.addOperationUpdateACLMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateACLOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateACLInput struct {
// The name of the Access Control List
//
// This member is required.
ACLName *string
// The list of users to add to the Access Control List
UserNamesToAdd []string
// The list of users to remove from the Access Control List
UserNamesToRemove []string
noSmithyDocumentSerde
}
type UpdateACLOutput struct {
// The updated Access Control List
ACL *types.ACL
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateACLMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateACL{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateACL{}, 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 = addOpUpdateACLValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateACL(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_opUpdateACL(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "UpdateACL",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Modifies the settings for a cluster. You can use this operation to change one
// or more cluster configuration settings by specifying the settings and the new
// values.
func (c *Client) UpdateCluster(ctx context.Context, params *UpdateClusterInput, optFns ...func(*Options)) (*UpdateClusterOutput, error) {
if params == nil {
params = &UpdateClusterInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateCluster", params, optFns, c.addOperationUpdateClusterMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateClusterOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateClusterInput struct {
// The name of the cluster to update
//
// This member is required.
ClusterName *string
// The Access Control List that is associated with the cluster
ACLName *string
// The description of the cluster to update
Description *string
// The upgraded version of the engine to be run on the nodes. You can upgrade to a
// newer engine version, but you cannot downgrade to an earlier engine version. If
// you want to use an earlier engine version, you must delete the existing cluster
// and create it anew with the earlier engine version.
EngineVersion *string
// Specifies the weekly time range during which maintenance on the cluster is
// performed. It is specified as a range in the format ddd:hh24:mi-ddd:hh24:mi (24H
// Clock UTC). The minimum maintenance window is a 60 minute period. Valid values
// for ddd are:
// - sun
// - mon
// - tue
// - wed
// - thu
// - fri
// - sat
// Example: sun:23:00-mon:01:30
MaintenanceWindow *string
// A valid node type that you want to scale this cluster up or down to.
NodeType *string
// The name of the parameter group to update
ParameterGroupName *string
// The number of replicas that will reside in each shard
ReplicaConfiguration *types.ReplicaConfigurationRequest
// The SecurityGroupIds to update
SecurityGroupIds []string
// The number of shards in the cluster
ShardConfiguration *types.ShardConfigurationRequest
// The number of days for which MemoryDB retains automatic cluster snapshots
// before deleting them. For example, if you set SnapshotRetentionLimit to 5, a
// snapshot that was taken today is retained for 5 days before being deleted.
SnapshotRetentionLimit *int32
// The daily time range (in UTC) during which MemoryDB begins taking a daily
// snapshot of your cluster.
SnapshotWindow *string
// The SNS topic ARN to update
SnsTopicArn *string
// The status of the Amazon SNS notification topic. Notifications are sent only if
// the status is active.
SnsTopicStatus *string
noSmithyDocumentSerde
}
type UpdateClusterOutput struct {
// The updated cluster
Cluster *types.Cluster
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateClusterMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateCluster{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateCluster{}, 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 = addOpUpdateClusterValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateCluster(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_opUpdateCluster(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "UpdateCluster",
}
}
| 184 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates the parameters of a parameter group. You can modify up to 20 parameters
// in a single request by submitting a list parameter name and value pairs.
func (c *Client) UpdateParameterGroup(ctx context.Context, params *UpdateParameterGroupInput, optFns ...func(*Options)) (*UpdateParameterGroupOutput, error) {
if params == nil {
params = &UpdateParameterGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateParameterGroup", params, optFns, c.addOperationUpdateParameterGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateParameterGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateParameterGroupInput struct {
// The name of the parameter group to update.
//
// This member is required.
ParameterGroupName *string
// An array of parameter names and values for the parameter update. You must
// supply at least one parameter name and value; subsequent arguments are optional.
// A maximum of 20 parameters may be updated per request.
//
// This member is required.
ParameterNameValues []types.ParameterNameValue
noSmithyDocumentSerde
}
type UpdateParameterGroupOutput struct {
// The updated parameter group
ParameterGroup *types.ParameterGroup
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateParameterGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateParameterGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateParameterGroup{}, 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 = addOpUpdateParameterGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateParameterGroup(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_opUpdateParameterGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "UpdateParameterGroup",
}
}
| 133 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates a subnet group. For more information, see Updating a subnet group (https://docs.aws.amazon.com/MemoryDB/latest/devguide/ubnetGroups.Modifying.html)
func (c *Client) UpdateSubnetGroup(ctx context.Context, params *UpdateSubnetGroupInput, optFns ...func(*Options)) (*UpdateSubnetGroupOutput, error) {
if params == nil {
params = &UpdateSubnetGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateSubnetGroup", params, optFns, c.addOperationUpdateSubnetGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateSubnetGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateSubnetGroupInput struct {
// The name of the subnet group
//
// This member is required.
SubnetGroupName *string
// A description of the subnet group
Description *string
// The EC2 subnet IDs for the subnet group.
SubnetIds []string
noSmithyDocumentSerde
}
type UpdateSubnetGroupOutput struct {
// The updated subnet group
SubnetGroup *types.SubnetGroup
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateSubnetGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateSubnetGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateSubnetGroup{}, 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 = addOpUpdateSubnetGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateSubnetGroup(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_opUpdateSubnetGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "UpdateSubnetGroup",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Changes user password(s) and/or access string.
func (c *Client) UpdateUser(ctx context.Context, params *UpdateUserInput, optFns ...func(*Options)) (*UpdateUserOutput, error) {
if params == nil {
params = &UpdateUserInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateUser", params, optFns, c.addOperationUpdateUserMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateUserOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateUserInput struct {
// The name of the user
//
// This member is required.
UserName *string
// Access permissions string used for this user.
AccessString *string
// Denotes the user's authentication properties, such as whether it requires a
// password to authenticate.
AuthenticationMode *types.AuthenticationMode
noSmithyDocumentSerde
}
type UpdateUserOutput struct {
// The updated user
User *types.User
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateUserMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpUpdateUser{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUpdateUser{}, 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 = addOpUpdateUserValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateUser(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_opUpdateUser(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "memorydb",
OperationName: "UpdateUser",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
import (
"bytes"
"context"
"encoding/json"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
"github.com/aws/aws-sdk-go-v2/service/memorydb/types"
smithy "github.com/aws/smithy-go"
smithyio "github.com/aws/smithy-go/io"
"github.com/aws/smithy-go/middleware"
"github.com/aws/smithy-go/ptr"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io"
"math"
"strings"
)
type awsAwsjson11_deserializeOpBatchUpdateCluster struct {
}
func (*awsAwsjson11_deserializeOpBatchUpdateCluster) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpBatchUpdateCluster) 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, awsAwsjson11_deserializeOpErrorBatchUpdateCluster(response, &metadata)
}
output := &BatchUpdateClusterOutput{}
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 = awsAwsjson11_deserializeOpDocumentBatchUpdateClusterOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorBatchUpdateCluster(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("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("ServiceUpdateNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceUpdateNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpCopySnapshot struct {
}
func (*awsAwsjson11_deserializeOpCopySnapshot) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpCopySnapshot) 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, awsAwsjson11_deserializeOpErrorCopySnapshot(response, &metadata)
}
output := &CopySnapshotOutput{}
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 = awsAwsjson11_deserializeOpDocumentCopySnapshotOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorCopySnapshot(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("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("InvalidSnapshotStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidSnapshotStateFault(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
case strings.EqualFold("SnapshotAlreadyExistsFault", errorCode):
return awsAwsjson11_deserializeErrorSnapshotAlreadyExistsFault(response, errorBody)
case strings.EqualFold("SnapshotNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorSnapshotNotFoundFault(response, errorBody)
case strings.EqualFold("SnapshotQuotaExceededFault", errorCode):
return awsAwsjson11_deserializeErrorSnapshotQuotaExceededFault(response, errorBody)
case strings.EqualFold("TagQuotaPerResourceExceeded", errorCode):
return awsAwsjson11_deserializeErrorTagQuotaPerResourceExceeded(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpCreateACL struct {
}
func (*awsAwsjson11_deserializeOpCreateACL) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpCreateACL) 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, awsAwsjson11_deserializeOpErrorCreateACL(response, &metadata)
}
output := &CreateACLOutput{}
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 = awsAwsjson11_deserializeOpDocumentCreateACLOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorCreateACL(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("ACLAlreadyExistsFault", errorCode):
return awsAwsjson11_deserializeErrorACLAlreadyExistsFault(response, errorBody)
case strings.EqualFold("ACLQuotaExceededFault", errorCode):
return awsAwsjson11_deserializeErrorACLQuotaExceededFault(response, errorBody)
case strings.EqualFold("DefaultUserRequired", errorCode):
return awsAwsjson11_deserializeErrorDefaultUserRequired(response, errorBody)
case strings.EqualFold("DuplicateUserNameFault", errorCode):
return awsAwsjson11_deserializeErrorDuplicateUserNameFault(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("TagQuotaPerResourceExceeded", errorCode):
return awsAwsjson11_deserializeErrorTagQuotaPerResourceExceeded(response, errorBody)
case strings.EqualFold("UserNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorUserNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpCreateCluster struct {
}
func (*awsAwsjson11_deserializeOpCreateCluster) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpCreateCluster) 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, awsAwsjson11_deserializeOpErrorCreateCluster(response, &metadata)
}
output := &CreateClusterOutput{}
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 = awsAwsjson11_deserializeOpDocumentCreateClusterOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorCreateCluster(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("ACLNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorACLNotFoundFault(response, errorBody)
case strings.EqualFold("ClusterAlreadyExistsFault", errorCode):
return awsAwsjson11_deserializeErrorClusterAlreadyExistsFault(response, errorBody)
case strings.EqualFold("ClusterQuotaForCustomerExceededFault", errorCode):
return awsAwsjson11_deserializeErrorClusterQuotaForCustomerExceededFault(response, errorBody)
case strings.EqualFold("InsufficientClusterCapacityFault", errorCode):
return awsAwsjson11_deserializeErrorInsufficientClusterCapacityFault(response, errorBody)
case strings.EqualFold("InvalidACLStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidACLStateFault(response, errorBody)
case strings.EqualFold("InvalidCredentialsException", errorCode):
return awsAwsjson11_deserializeErrorInvalidCredentialsException(response, errorBody)
case strings.EqualFold("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody)
case strings.EqualFold("NodeQuotaForClusterExceededFault", errorCode):
return awsAwsjson11_deserializeErrorNodeQuotaForClusterExceededFault(response, errorBody)
case strings.EqualFold("NodeQuotaForCustomerExceededFault", errorCode):
return awsAwsjson11_deserializeErrorNodeQuotaForCustomerExceededFault(response, errorBody)
case strings.EqualFold("ParameterGroupNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorParameterGroupNotFoundFault(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
case strings.EqualFold("ShardsPerClusterQuotaExceededFault", errorCode):
return awsAwsjson11_deserializeErrorShardsPerClusterQuotaExceededFault(response, errorBody)
case strings.EqualFold("SubnetGroupNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorSubnetGroupNotFoundFault(response, errorBody)
case strings.EqualFold("TagQuotaPerResourceExceeded", errorCode):
return awsAwsjson11_deserializeErrorTagQuotaPerResourceExceeded(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpCreateParameterGroup struct {
}
func (*awsAwsjson11_deserializeOpCreateParameterGroup) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpCreateParameterGroup) 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, awsAwsjson11_deserializeOpErrorCreateParameterGroup(response, &metadata)
}
output := &CreateParameterGroupOutput{}
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 = awsAwsjson11_deserializeOpDocumentCreateParameterGroupOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorCreateParameterGroup(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("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterGroupStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterGroupStateFault(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("ParameterGroupAlreadyExistsFault", errorCode):
return awsAwsjson11_deserializeErrorParameterGroupAlreadyExistsFault(response, errorBody)
case strings.EqualFold("ParameterGroupQuotaExceededFault", errorCode):
return awsAwsjson11_deserializeErrorParameterGroupQuotaExceededFault(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
case strings.EqualFold("TagQuotaPerResourceExceeded", errorCode):
return awsAwsjson11_deserializeErrorTagQuotaPerResourceExceeded(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpCreateSnapshot struct {
}
func (*awsAwsjson11_deserializeOpCreateSnapshot) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpCreateSnapshot) 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, awsAwsjson11_deserializeOpErrorCreateSnapshot(response, &metadata)
}
output := &CreateSnapshotOutput{}
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 = awsAwsjson11_deserializeOpDocumentCreateSnapshotOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorCreateSnapshot(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("ClusterNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorClusterNotFoundFault(response, errorBody)
case strings.EqualFold("InvalidClusterStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidClusterStateFault(response, errorBody)
case strings.EqualFold("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
case strings.EqualFold("SnapshotAlreadyExistsFault", errorCode):
return awsAwsjson11_deserializeErrorSnapshotAlreadyExistsFault(response, errorBody)
case strings.EqualFold("SnapshotQuotaExceededFault", errorCode):
return awsAwsjson11_deserializeErrorSnapshotQuotaExceededFault(response, errorBody)
case strings.EqualFold("TagQuotaPerResourceExceeded", errorCode):
return awsAwsjson11_deserializeErrorTagQuotaPerResourceExceeded(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpCreateSubnetGroup struct {
}
func (*awsAwsjson11_deserializeOpCreateSubnetGroup) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpCreateSubnetGroup) 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, awsAwsjson11_deserializeOpErrorCreateSubnetGroup(response, &metadata)
}
output := &CreateSubnetGroupOutput{}
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 = awsAwsjson11_deserializeOpDocumentCreateSubnetGroupOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorCreateSubnetGroup(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("InvalidSubnet", errorCode):
return awsAwsjson11_deserializeErrorInvalidSubnet(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
case strings.EqualFold("SubnetGroupAlreadyExistsFault", errorCode):
return awsAwsjson11_deserializeErrorSubnetGroupAlreadyExistsFault(response, errorBody)
case strings.EqualFold("SubnetGroupQuotaExceededFault", errorCode):
return awsAwsjson11_deserializeErrorSubnetGroupQuotaExceededFault(response, errorBody)
case strings.EqualFold("SubnetNotAllowedFault", errorCode):
return awsAwsjson11_deserializeErrorSubnetNotAllowedFault(response, errorBody)
case strings.EqualFold("SubnetQuotaExceededFault", errorCode):
return awsAwsjson11_deserializeErrorSubnetQuotaExceededFault(response, errorBody)
case strings.EqualFold("TagQuotaPerResourceExceeded", errorCode):
return awsAwsjson11_deserializeErrorTagQuotaPerResourceExceeded(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpCreateUser struct {
}
func (*awsAwsjson11_deserializeOpCreateUser) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpCreateUser) 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, awsAwsjson11_deserializeOpErrorCreateUser(response, &metadata)
}
output := &CreateUserOutput{}
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 = awsAwsjson11_deserializeOpDocumentCreateUserOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorCreateUser(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("DuplicateUserNameFault", errorCode):
return awsAwsjson11_deserializeErrorDuplicateUserNameFault(response, errorBody)
case strings.EqualFold("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("TagQuotaPerResourceExceeded", errorCode):
return awsAwsjson11_deserializeErrorTagQuotaPerResourceExceeded(response, errorBody)
case strings.EqualFold("UserAlreadyExistsFault", errorCode):
return awsAwsjson11_deserializeErrorUserAlreadyExistsFault(response, errorBody)
case strings.EqualFold("UserQuotaExceededFault", errorCode):
return awsAwsjson11_deserializeErrorUserQuotaExceededFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDeleteACL struct {
}
func (*awsAwsjson11_deserializeOpDeleteACL) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDeleteACL) 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, awsAwsjson11_deserializeOpErrorDeleteACL(response, &metadata)
}
output := &DeleteACLOutput{}
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 = awsAwsjson11_deserializeOpDocumentDeleteACLOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDeleteACL(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("ACLNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorACLNotFoundFault(response, errorBody)
case strings.EqualFold("InvalidACLStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidACLStateFault(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDeleteCluster struct {
}
func (*awsAwsjson11_deserializeOpDeleteCluster) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDeleteCluster) 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, awsAwsjson11_deserializeOpErrorDeleteCluster(response, &metadata)
}
output := &DeleteClusterOutput{}
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 = awsAwsjson11_deserializeOpDocumentDeleteClusterOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDeleteCluster(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("ClusterNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorClusterNotFoundFault(response, errorBody)
case strings.EqualFold("InvalidClusterStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidClusterStateFault(response, errorBody)
case strings.EqualFold("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
case strings.EqualFold("SnapshotAlreadyExistsFault", errorCode):
return awsAwsjson11_deserializeErrorSnapshotAlreadyExistsFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDeleteParameterGroup struct {
}
func (*awsAwsjson11_deserializeOpDeleteParameterGroup) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDeleteParameterGroup) 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, awsAwsjson11_deserializeOpErrorDeleteParameterGroup(response, &metadata)
}
output := &DeleteParameterGroupOutput{}
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 = awsAwsjson11_deserializeOpDocumentDeleteParameterGroupOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDeleteParameterGroup(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("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterGroupStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterGroupStateFault(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("ParameterGroupNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorParameterGroupNotFoundFault(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDeleteSnapshot struct {
}
func (*awsAwsjson11_deserializeOpDeleteSnapshot) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDeleteSnapshot) 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, awsAwsjson11_deserializeOpErrorDeleteSnapshot(response, &metadata)
}
output := &DeleteSnapshotOutput{}
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 = awsAwsjson11_deserializeOpDocumentDeleteSnapshotOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDeleteSnapshot(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("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("InvalidSnapshotStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidSnapshotStateFault(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
case strings.EqualFold("SnapshotNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorSnapshotNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDeleteSubnetGroup struct {
}
func (*awsAwsjson11_deserializeOpDeleteSubnetGroup) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDeleteSubnetGroup) 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, awsAwsjson11_deserializeOpErrorDeleteSubnetGroup(response, &metadata)
}
output := &DeleteSubnetGroupOutput{}
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 = awsAwsjson11_deserializeOpDocumentDeleteSubnetGroupOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDeleteSubnetGroup(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("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
case strings.EqualFold("SubnetGroupInUseFault", errorCode):
return awsAwsjson11_deserializeErrorSubnetGroupInUseFault(response, errorBody)
case strings.EqualFold("SubnetGroupNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorSubnetGroupNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDeleteUser struct {
}
func (*awsAwsjson11_deserializeOpDeleteUser) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDeleteUser) 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, awsAwsjson11_deserializeOpErrorDeleteUser(response, &metadata)
}
output := &DeleteUserOutput{}
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 = awsAwsjson11_deserializeOpDocumentDeleteUserOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDeleteUser(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("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("InvalidUserStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidUserStateFault(response, errorBody)
case strings.EqualFold("UserNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorUserNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeACLs struct {
}
func (*awsAwsjson11_deserializeOpDescribeACLs) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeACLs) 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, awsAwsjson11_deserializeOpErrorDescribeACLs(response, &metadata)
}
output := &DescribeACLsOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeACLsOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeACLs(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("ACLNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorACLNotFoundFault(response, errorBody)
case strings.EqualFold("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeClusters struct {
}
func (*awsAwsjson11_deserializeOpDescribeClusters) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeClusters) 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, awsAwsjson11_deserializeOpErrorDescribeClusters(response, &metadata)
}
output := &DescribeClustersOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeClustersOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeClusters(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("ClusterNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorClusterNotFoundFault(response, errorBody)
case strings.EqualFold("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeEngineVersions struct {
}
func (*awsAwsjson11_deserializeOpDescribeEngineVersions) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeEngineVersions) 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, awsAwsjson11_deserializeOpErrorDescribeEngineVersions(response, &metadata)
}
output := &DescribeEngineVersionsOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeEngineVersionsOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeEngineVersions(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("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeEvents struct {
}
func (*awsAwsjson11_deserializeOpDescribeEvents) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeEvents) 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, awsAwsjson11_deserializeOpErrorDescribeEvents(response, &metadata)
}
output := &DescribeEventsOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeEventsOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeEvents(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("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeParameterGroups struct {
}
func (*awsAwsjson11_deserializeOpDescribeParameterGroups) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeParameterGroups) 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, awsAwsjson11_deserializeOpErrorDescribeParameterGroups(response, &metadata)
}
output := &DescribeParameterGroupsOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeParameterGroupsOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeParameterGroups(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("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("ParameterGroupNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorParameterGroupNotFoundFault(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeParameters struct {
}
func (*awsAwsjson11_deserializeOpDescribeParameters) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeParameters) 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, awsAwsjson11_deserializeOpErrorDescribeParameters(response, &metadata)
}
output := &DescribeParametersOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeParametersOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeParameters(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("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("ParameterGroupNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorParameterGroupNotFoundFault(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeReservedNodes struct {
}
func (*awsAwsjson11_deserializeOpDescribeReservedNodes) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeReservedNodes) 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, awsAwsjson11_deserializeOpErrorDescribeReservedNodes(response, &metadata)
}
output := &DescribeReservedNodesOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeReservedNodesOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeReservedNodes(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("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("ReservedNodeNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorReservedNodeNotFoundFault(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeReservedNodesOfferings struct {
}
func (*awsAwsjson11_deserializeOpDescribeReservedNodesOfferings) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeReservedNodesOfferings) 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, awsAwsjson11_deserializeOpErrorDescribeReservedNodesOfferings(response, &metadata)
}
output := &DescribeReservedNodesOfferingsOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeReservedNodesOfferingsOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeReservedNodesOfferings(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("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("ReservedNodesOfferingNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorReservedNodesOfferingNotFoundFault(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeServiceUpdates struct {
}
func (*awsAwsjson11_deserializeOpDescribeServiceUpdates) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeServiceUpdates) 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, awsAwsjson11_deserializeOpErrorDescribeServiceUpdates(response, &metadata)
}
output := &DescribeServiceUpdatesOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeServiceUpdatesOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeServiceUpdates(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("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeSnapshots struct {
}
func (*awsAwsjson11_deserializeOpDescribeSnapshots) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeSnapshots) 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, awsAwsjson11_deserializeOpErrorDescribeSnapshots(response, &metadata)
}
output := &DescribeSnapshotsOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeSnapshotsOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeSnapshots(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("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
case strings.EqualFold("SnapshotNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorSnapshotNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeSubnetGroups struct {
}
func (*awsAwsjson11_deserializeOpDescribeSubnetGroups) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeSubnetGroups) 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, awsAwsjson11_deserializeOpErrorDescribeSubnetGroups(response, &metadata)
}
output := &DescribeSubnetGroupsOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeSubnetGroupsOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeSubnetGroups(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("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
case strings.EqualFold("SubnetGroupNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorSubnetGroupNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDescribeUsers struct {
}
func (*awsAwsjson11_deserializeOpDescribeUsers) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDescribeUsers) 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, awsAwsjson11_deserializeOpErrorDescribeUsers(response, &metadata)
}
output := &DescribeUsersOutput{}
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 = awsAwsjson11_deserializeOpDocumentDescribeUsersOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDescribeUsers(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("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("UserNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorUserNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpFailoverShard struct {
}
func (*awsAwsjson11_deserializeOpFailoverShard) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpFailoverShard) 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, awsAwsjson11_deserializeOpErrorFailoverShard(response, &metadata)
}
output := &FailoverShardOutput{}
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 = awsAwsjson11_deserializeOpDocumentFailoverShardOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorFailoverShard(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("APICallRateForCustomerExceededFault", errorCode):
return awsAwsjson11_deserializeErrorAPICallRateForCustomerExceededFault(response, errorBody)
case strings.EqualFold("ClusterNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorClusterNotFoundFault(response, errorBody)
case strings.EqualFold("InvalidClusterStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidClusterStateFault(response, errorBody)
case strings.EqualFold("InvalidKMSKeyFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidKMSKeyFault(response, errorBody)
case strings.EqualFold("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("ShardNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorShardNotFoundFault(response, errorBody)
case strings.EqualFold("TestFailoverNotAvailableFault", errorCode):
return awsAwsjson11_deserializeErrorTestFailoverNotAvailableFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpListAllowedNodeTypeUpdates struct {
}
func (*awsAwsjson11_deserializeOpListAllowedNodeTypeUpdates) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpListAllowedNodeTypeUpdates) 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, awsAwsjson11_deserializeOpErrorListAllowedNodeTypeUpdates(response, &metadata)
}
output := &ListAllowedNodeTypeUpdatesOutput{}
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 = awsAwsjson11_deserializeOpDocumentListAllowedNodeTypeUpdatesOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorListAllowedNodeTypeUpdates(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("ClusterNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorClusterNotFoundFault(response, errorBody)
case strings.EqualFold("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpListTags struct {
}
func (*awsAwsjson11_deserializeOpListTags) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpListTags) 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, awsAwsjson11_deserializeOpErrorListTags(response, &metadata)
}
output := &ListTagsOutput{}
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 = awsAwsjson11_deserializeOpDocumentListTagsOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorListTags(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("ACLNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorACLNotFoundFault(response, errorBody)
case strings.EqualFold("ClusterNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorClusterNotFoundFault(response, errorBody)
case strings.EqualFold("InvalidARNFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidARNFault(response, errorBody)
case strings.EqualFold("InvalidClusterStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidClusterStateFault(response, errorBody)
case strings.EqualFold("ParameterGroupNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorParameterGroupNotFoundFault(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
case strings.EqualFold("SnapshotNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorSnapshotNotFoundFault(response, errorBody)
case strings.EqualFold("SubnetGroupNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorSubnetGroupNotFoundFault(response, errorBody)
case strings.EqualFold("UserNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorUserNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpPurchaseReservedNodesOffering struct {
}
func (*awsAwsjson11_deserializeOpPurchaseReservedNodesOffering) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpPurchaseReservedNodesOffering) 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, awsAwsjson11_deserializeOpErrorPurchaseReservedNodesOffering(response, &metadata)
}
output := &PurchaseReservedNodesOfferingOutput{}
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 = awsAwsjson11_deserializeOpDocumentPurchaseReservedNodesOfferingOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorPurchaseReservedNodesOffering(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("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("ReservedNodeAlreadyExistsFault", errorCode):
return awsAwsjson11_deserializeErrorReservedNodeAlreadyExistsFault(response, errorBody)
case strings.EqualFold("ReservedNodeQuotaExceededFault", errorCode):
return awsAwsjson11_deserializeErrorReservedNodeQuotaExceededFault(response, errorBody)
case strings.EqualFold("ReservedNodesOfferingNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorReservedNodesOfferingNotFoundFault(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
case strings.EqualFold("TagQuotaPerResourceExceeded", errorCode):
return awsAwsjson11_deserializeErrorTagQuotaPerResourceExceeded(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpResetParameterGroup struct {
}
func (*awsAwsjson11_deserializeOpResetParameterGroup) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpResetParameterGroup) 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, awsAwsjson11_deserializeOpErrorResetParameterGroup(response, &metadata)
}
output := &ResetParameterGroupOutput{}
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 = awsAwsjson11_deserializeOpDocumentResetParameterGroupOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorResetParameterGroup(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("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterGroupStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterGroupStateFault(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("ParameterGroupNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorParameterGroupNotFoundFault(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpTagResource struct {
}
func (*awsAwsjson11_deserializeOpTagResource) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_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, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata)
}
output := &TagResourceOutput{}
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 = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_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("ACLNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorACLNotFoundFault(response, errorBody)
case strings.EqualFold("ClusterNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorClusterNotFoundFault(response, errorBody)
case strings.EqualFold("InvalidARNFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidARNFault(response, errorBody)
case strings.EqualFold("InvalidClusterStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidClusterStateFault(response, errorBody)
case strings.EqualFold("ParameterGroupNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorParameterGroupNotFoundFault(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
case strings.EqualFold("SnapshotNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorSnapshotNotFoundFault(response, errorBody)
case strings.EqualFold("SubnetGroupNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorSubnetGroupNotFoundFault(response, errorBody)
case strings.EqualFold("TagQuotaPerResourceExceeded", errorCode):
return awsAwsjson11_deserializeErrorTagQuotaPerResourceExceeded(response, errorBody)
case strings.EqualFold("UserNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorUserNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpUntagResource struct {
}
func (*awsAwsjson11_deserializeOpUntagResource) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_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, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata)
}
output := &UntagResourceOutput{}
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 = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_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("ACLNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorACLNotFoundFault(response, errorBody)
case strings.EqualFold("ClusterNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorClusterNotFoundFault(response, errorBody)
case strings.EqualFold("InvalidARNFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidARNFault(response, errorBody)
case strings.EqualFold("InvalidClusterStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidClusterStateFault(response, errorBody)
case strings.EqualFold("ParameterGroupNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorParameterGroupNotFoundFault(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
case strings.EqualFold("SnapshotNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorSnapshotNotFoundFault(response, errorBody)
case strings.EqualFold("SubnetGroupNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorSubnetGroupNotFoundFault(response, errorBody)
case strings.EqualFold("TagNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorTagNotFoundFault(response, errorBody)
case strings.EqualFold("UserNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorUserNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpUpdateACL struct {
}
func (*awsAwsjson11_deserializeOpUpdateACL) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpUpdateACL) 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, awsAwsjson11_deserializeOpErrorUpdateACL(response, &metadata)
}
output := &UpdateACLOutput{}
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 = awsAwsjson11_deserializeOpDocumentUpdateACLOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorUpdateACL(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("ACLNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorACLNotFoundFault(response, errorBody)
case strings.EqualFold("DefaultUserRequired", errorCode):
return awsAwsjson11_deserializeErrorDefaultUserRequired(response, errorBody)
case strings.EqualFold("DuplicateUserNameFault", errorCode):
return awsAwsjson11_deserializeErrorDuplicateUserNameFault(response, errorBody)
case strings.EqualFold("InvalidACLStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidACLStateFault(response, errorBody)
case strings.EqualFold("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("UserNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorUserNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpUpdateCluster struct {
}
func (*awsAwsjson11_deserializeOpUpdateCluster) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpUpdateCluster) 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, awsAwsjson11_deserializeOpErrorUpdateCluster(response, &metadata)
}
output := &UpdateClusterOutput{}
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 = awsAwsjson11_deserializeOpDocumentUpdateClusterOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorUpdateCluster(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("ACLNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorACLNotFoundFault(response, errorBody)
case strings.EqualFold("ClusterNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorClusterNotFoundFault(response, errorBody)
case strings.EqualFold("ClusterQuotaForCustomerExceededFault", errorCode):
return awsAwsjson11_deserializeErrorClusterQuotaForCustomerExceededFault(response, errorBody)
case strings.EqualFold("InvalidACLStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidACLStateFault(response, errorBody)
case strings.EqualFold("InvalidClusterStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidClusterStateFault(response, errorBody)
case strings.EqualFold("InvalidKMSKeyFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidKMSKeyFault(response, errorBody)
case strings.EqualFold("InvalidNodeStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidNodeStateFault(response, errorBody)
case strings.EqualFold("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("InvalidVPCNetworkStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidVPCNetworkStateFault(response, errorBody)
case strings.EqualFold("NoOperationFault", errorCode):
return awsAwsjson11_deserializeErrorNoOperationFault(response, errorBody)
case strings.EqualFold("NodeQuotaForClusterExceededFault", errorCode):
return awsAwsjson11_deserializeErrorNodeQuotaForClusterExceededFault(response, errorBody)
case strings.EqualFold("NodeQuotaForCustomerExceededFault", errorCode):
return awsAwsjson11_deserializeErrorNodeQuotaForCustomerExceededFault(response, errorBody)
case strings.EqualFold("ParameterGroupNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorParameterGroupNotFoundFault(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
case strings.EqualFold("ShardsPerClusterQuotaExceededFault", errorCode):
return awsAwsjson11_deserializeErrorShardsPerClusterQuotaExceededFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpUpdateParameterGroup struct {
}
func (*awsAwsjson11_deserializeOpUpdateParameterGroup) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpUpdateParameterGroup) 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, awsAwsjson11_deserializeOpErrorUpdateParameterGroup(response, &metadata)
}
output := &UpdateParameterGroupOutput{}
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 = awsAwsjson11_deserializeOpDocumentUpdateParameterGroupOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorUpdateParameterGroup(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("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterGroupStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterGroupStateFault(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("ParameterGroupNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorParameterGroupNotFoundFault(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpUpdateSubnetGroup struct {
}
func (*awsAwsjson11_deserializeOpUpdateSubnetGroup) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpUpdateSubnetGroup) 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, awsAwsjson11_deserializeOpErrorUpdateSubnetGroup(response, &metadata)
}
output := &UpdateSubnetGroupOutput{}
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 = awsAwsjson11_deserializeOpDocumentUpdateSubnetGroupOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorUpdateSubnetGroup(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("InvalidSubnet", errorCode):
return awsAwsjson11_deserializeErrorInvalidSubnet(response, errorBody)
case strings.EqualFold("ServiceLinkedRoleNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response, errorBody)
case strings.EqualFold("SubnetGroupNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorSubnetGroupNotFoundFault(response, errorBody)
case strings.EqualFold("SubnetInUse", errorCode):
return awsAwsjson11_deserializeErrorSubnetInUse(response, errorBody)
case strings.EqualFold("SubnetNotAllowedFault", errorCode):
return awsAwsjson11_deserializeErrorSubnetNotAllowedFault(response, errorBody)
case strings.EqualFold("SubnetQuotaExceededFault", errorCode):
return awsAwsjson11_deserializeErrorSubnetQuotaExceededFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpUpdateUser struct {
}
func (*awsAwsjson11_deserializeOpUpdateUser) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpUpdateUser) 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, awsAwsjson11_deserializeOpErrorUpdateUser(response, &metadata)
}
output := &UpdateUserOutput{}
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 = awsAwsjson11_deserializeOpDocumentUpdateUserOutput(&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 out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorUpdateUser(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("InvalidParameterCombinationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody)
case strings.EqualFold("InvalidParameterValueException", errorCode):
return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody)
case strings.EqualFold("InvalidUserStateFault", errorCode):
return awsAwsjson11_deserializeErrorInvalidUserStateFault(response, errorBody)
case strings.EqualFold("UserNotFoundFault", errorCode):
return awsAwsjson11_deserializeErrorUserNotFoundFault(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsAwsjson11_deserializeErrorACLAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.ACLAlreadyExistsFault{}
err := awsAwsjson11_deserializeDocumentACLAlreadyExistsFault(&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 awsAwsjson11_deserializeErrorACLNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.ACLNotFoundFault{}
err := awsAwsjson11_deserializeDocumentACLNotFoundFault(&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 awsAwsjson11_deserializeErrorACLQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.ACLQuotaExceededFault{}
err := awsAwsjson11_deserializeDocumentACLQuotaExceededFault(&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 awsAwsjson11_deserializeErrorAPICallRateForCustomerExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.APICallRateForCustomerExceededFault{}
err := awsAwsjson11_deserializeDocumentAPICallRateForCustomerExceededFault(&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 awsAwsjson11_deserializeErrorClusterAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.ClusterAlreadyExistsFault{}
err := awsAwsjson11_deserializeDocumentClusterAlreadyExistsFault(&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 awsAwsjson11_deserializeErrorClusterNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.ClusterNotFoundFault{}
err := awsAwsjson11_deserializeDocumentClusterNotFoundFault(&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 awsAwsjson11_deserializeErrorClusterQuotaForCustomerExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.ClusterQuotaForCustomerExceededFault{}
err := awsAwsjson11_deserializeDocumentClusterQuotaForCustomerExceededFault(&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 awsAwsjson11_deserializeErrorDefaultUserRequired(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.DefaultUserRequired{}
err := awsAwsjson11_deserializeDocumentDefaultUserRequired(&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 awsAwsjson11_deserializeErrorDuplicateUserNameFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.DuplicateUserNameFault{}
err := awsAwsjson11_deserializeDocumentDuplicateUserNameFault(&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 awsAwsjson11_deserializeErrorInsufficientClusterCapacityFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.InsufficientClusterCapacityFault{}
err := awsAwsjson11_deserializeDocumentInsufficientClusterCapacityFault(&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 awsAwsjson11_deserializeErrorInvalidACLStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.InvalidACLStateFault{}
err := awsAwsjson11_deserializeDocumentInvalidACLStateFault(&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 awsAwsjson11_deserializeErrorInvalidARNFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.InvalidARNFault{}
err := awsAwsjson11_deserializeDocumentInvalidARNFault(&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 awsAwsjson11_deserializeErrorInvalidClusterStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.InvalidClusterStateFault{}
err := awsAwsjson11_deserializeDocumentInvalidClusterStateFault(&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 awsAwsjson11_deserializeErrorInvalidCredentialsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.InvalidCredentialsException{}
err := awsAwsjson11_deserializeDocumentInvalidCredentialsException(&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 awsAwsjson11_deserializeErrorInvalidKMSKeyFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.InvalidKMSKeyFault{}
err := awsAwsjson11_deserializeDocumentInvalidKMSKeyFault(&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 awsAwsjson11_deserializeErrorInvalidNodeStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.InvalidNodeStateFault{}
err := awsAwsjson11_deserializeDocumentInvalidNodeStateFault(&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 awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.InvalidParameterCombinationException{}
err := awsAwsjson11_deserializeDocumentInvalidParameterCombinationException(&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 awsAwsjson11_deserializeErrorInvalidParameterGroupStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.InvalidParameterGroupStateFault{}
err := awsAwsjson11_deserializeDocumentInvalidParameterGroupStateFault(&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 awsAwsjson11_deserializeErrorInvalidParameterValueException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.InvalidParameterValueException{}
err := awsAwsjson11_deserializeDocumentInvalidParameterValueException(&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 awsAwsjson11_deserializeErrorInvalidSnapshotStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.InvalidSnapshotStateFault{}
err := awsAwsjson11_deserializeDocumentInvalidSnapshotStateFault(&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 awsAwsjson11_deserializeErrorInvalidSubnet(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.InvalidSubnet{}
err := awsAwsjson11_deserializeDocumentInvalidSubnet(&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 awsAwsjson11_deserializeErrorInvalidUserStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.InvalidUserStateFault{}
err := awsAwsjson11_deserializeDocumentInvalidUserStateFault(&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 awsAwsjson11_deserializeErrorInvalidVPCNetworkStateFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.InvalidVPCNetworkStateFault{}
err := awsAwsjson11_deserializeDocumentInvalidVPCNetworkStateFault(&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 awsAwsjson11_deserializeErrorNodeQuotaForClusterExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.NodeQuotaForClusterExceededFault{}
err := awsAwsjson11_deserializeDocumentNodeQuotaForClusterExceededFault(&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 awsAwsjson11_deserializeErrorNodeQuotaForCustomerExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.NodeQuotaForCustomerExceededFault{}
err := awsAwsjson11_deserializeDocumentNodeQuotaForCustomerExceededFault(&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 awsAwsjson11_deserializeErrorNoOperationFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.NoOperationFault{}
err := awsAwsjson11_deserializeDocumentNoOperationFault(&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 awsAwsjson11_deserializeErrorParameterGroupAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.ParameterGroupAlreadyExistsFault{}
err := awsAwsjson11_deserializeDocumentParameterGroupAlreadyExistsFault(&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 awsAwsjson11_deserializeErrorParameterGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.ParameterGroupNotFoundFault{}
err := awsAwsjson11_deserializeDocumentParameterGroupNotFoundFault(&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 awsAwsjson11_deserializeErrorParameterGroupQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.ParameterGroupQuotaExceededFault{}
err := awsAwsjson11_deserializeDocumentParameterGroupQuotaExceededFault(&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 awsAwsjson11_deserializeErrorReservedNodeAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.ReservedNodeAlreadyExistsFault{}
err := awsAwsjson11_deserializeDocumentReservedNodeAlreadyExistsFault(&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 awsAwsjson11_deserializeErrorReservedNodeNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.ReservedNodeNotFoundFault{}
err := awsAwsjson11_deserializeDocumentReservedNodeNotFoundFault(&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 awsAwsjson11_deserializeErrorReservedNodeQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.ReservedNodeQuotaExceededFault{}
err := awsAwsjson11_deserializeDocumentReservedNodeQuotaExceededFault(&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 awsAwsjson11_deserializeErrorReservedNodesOfferingNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.ReservedNodesOfferingNotFoundFault{}
err := awsAwsjson11_deserializeDocumentReservedNodesOfferingNotFoundFault(&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 awsAwsjson11_deserializeErrorServiceLinkedRoleNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.ServiceLinkedRoleNotFoundFault{}
err := awsAwsjson11_deserializeDocumentServiceLinkedRoleNotFoundFault(&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 awsAwsjson11_deserializeErrorServiceUpdateNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.ServiceUpdateNotFoundFault{}
err := awsAwsjson11_deserializeDocumentServiceUpdateNotFoundFault(&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 awsAwsjson11_deserializeErrorShardNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.ShardNotFoundFault{}
err := awsAwsjson11_deserializeDocumentShardNotFoundFault(&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 awsAwsjson11_deserializeErrorShardsPerClusterQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.ShardsPerClusterQuotaExceededFault{}
err := awsAwsjson11_deserializeDocumentShardsPerClusterQuotaExceededFault(&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 awsAwsjson11_deserializeErrorSnapshotAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.SnapshotAlreadyExistsFault{}
err := awsAwsjson11_deserializeDocumentSnapshotAlreadyExistsFault(&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 awsAwsjson11_deserializeErrorSnapshotNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.SnapshotNotFoundFault{}
err := awsAwsjson11_deserializeDocumentSnapshotNotFoundFault(&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 awsAwsjson11_deserializeErrorSnapshotQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.SnapshotQuotaExceededFault{}
err := awsAwsjson11_deserializeDocumentSnapshotQuotaExceededFault(&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 awsAwsjson11_deserializeErrorSubnetGroupAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.SubnetGroupAlreadyExistsFault{}
err := awsAwsjson11_deserializeDocumentSubnetGroupAlreadyExistsFault(&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 awsAwsjson11_deserializeErrorSubnetGroupInUseFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.SubnetGroupInUseFault{}
err := awsAwsjson11_deserializeDocumentSubnetGroupInUseFault(&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 awsAwsjson11_deserializeErrorSubnetGroupNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.SubnetGroupNotFoundFault{}
err := awsAwsjson11_deserializeDocumentSubnetGroupNotFoundFault(&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 awsAwsjson11_deserializeErrorSubnetGroupQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.SubnetGroupQuotaExceededFault{}
err := awsAwsjson11_deserializeDocumentSubnetGroupQuotaExceededFault(&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 awsAwsjson11_deserializeErrorSubnetInUse(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.SubnetInUse{}
err := awsAwsjson11_deserializeDocumentSubnetInUse(&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 awsAwsjson11_deserializeErrorSubnetNotAllowedFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.SubnetNotAllowedFault{}
err := awsAwsjson11_deserializeDocumentSubnetNotAllowedFault(&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 awsAwsjson11_deserializeErrorSubnetQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.SubnetQuotaExceededFault{}
err := awsAwsjson11_deserializeDocumentSubnetQuotaExceededFault(&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 awsAwsjson11_deserializeErrorTagNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.TagNotFoundFault{}
err := awsAwsjson11_deserializeDocumentTagNotFoundFault(&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 awsAwsjson11_deserializeErrorTagQuotaPerResourceExceeded(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.TagQuotaPerResourceExceeded{}
err := awsAwsjson11_deserializeDocumentTagQuotaPerResourceExceeded(&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 awsAwsjson11_deserializeErrorTestFailoverNotAvailableFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.TestFailoverNotAvailableFault{}
err := awsAwsjson11_deserializeDocumentTestFailoverNotAvailableFault(&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 awsAwsjson11_deserializeErrorUserAlreadyExistsFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.UserAlreadyExistsFault{}
err := awsAwsjson11_deserializeDocumentUserAlreadyExistsFault(&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 awsAwsjson11_deserializeErrorUserNotFoundFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.UserNotFoundFault{}
err := awsAwsjson11_deserializeDocumentUserNotFoundFault(&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 awsAwsjson11_deserializeErrorUserQuotaExceededFault(response *smithyhttp.Response, errorBody *bytes.Reader) error {
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
}
output := &types.UserQuotaExceededFault{}
err := awsAwsjson11_deserializeDocumentUserQuotaExceededFault(&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 awsAwsjson11_deserializeDocumentACL(v **types.ACL, 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.ACL
if *v == nil {
sv = &types.ACL{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ARN":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ARN = ptr.String(jtv)
}
case "Clusters":
if err := awsAwsjson11_deserializeDocumentACLClusterNameList(&sv.Clusters, value); err != nil {
return err
}
case "MinimumEngineVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.MinimumEngineVersion = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "PendingChanges":
if err := awsAwsjson11_deserializeDocumentACLPendingChanges(&sv.PendingChanges, value); err != nil {
return err
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Status = ptr.String(jtv)
}
case "UserNames":
if err := awsAwsjson11_deserializeDocumentUserNameList(&sv.UserNames, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentACLAlreadyExistsFault(v **types.ACLAlreadyExistsFault, 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.ACLAlreadyExistsFault
if *v == nil {
sv = &types.ACLAlreadyExistsFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentACLClusterNameList(v *[]string, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []string
if *v == nil {
cv = []string{}
} else {
cv = *v
}
for _, value := range shape {
var col string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentACLList(v *[]types.ACL, 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.ACL
if *v == nil {
cv = []types.ACL{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ACL
destAddr := &col
if err := awsAwsjson11_deserializeDocumentACL(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentACLNameList(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 ACLName to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentACLNotFoundFault(v **types.ACLNotFoundFault, 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.ACLNotFoundFault
if *v == nil {
sv = &types.ACLNotFoundFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentACLPendingChanges(v **types.ACLPendingChanges, 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.ACLPendingChanges
if *v == nil {
sv = &types.ACLPendingChanges{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "UserNamesToAdd":
if err := awsAwsjson11_deserializeDocumentUserNameList(&sv.UserNamesToAdd, value); err != nil {
return err
}
case "UserNamesToRemove":
if err := awsAwsjson11_deserializeDocumentUserNameList(&sv.UserNamesToRemove, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentACLQuotaExceededFault(v **types.ACLQuotaExceededFault, 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.ACLQuotaExceededFault
if *v == nil {
sv = &types.ACLQuotaExceededFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentACLsUpdateStatus(v **types.ACLsUpdateStatus, 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.ACLsUpdateStatus
if *v == nil {
sv = &types.ACLsUpdateStatus{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ACLToApply":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ACLName to be of type string, got %T instead", value)
}
sv.ACLToApply = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentAPICallRateForCustomerExceededFault(v **types.APICallRateForCustomerExceededFault, 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.APICallRateForCustomerExceededFault
if *v == nil {
sv = &types.APICallRateForCustomerExceededFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentAuthentication(v **types.Authentication, 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.Authentication
if *v == nil {
sv = &types.Authentication{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "PasswordCount":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected IntegerOptional to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.PasswordCount = ptr.Int32(int32(i64))
}
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AuthenticationType to be of type string, got %T instead", value)
}
sv.Type = types.AuthenticationType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentAvailabilityZone(v **types.AvailabilityZone, 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.AvailabilityZone
if *v == nil {
sv = &types.AvailabilityZone{}
} 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 String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentCluster(v **types.Cluster, 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.Cluster
if *v == nil {
sv = &types.Cluster{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ACLName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ACLName to be of type string, got %T instead", value)
}
sv.ACLName = ptr.String(jtv)
}
case "ARN":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ARN = ptr.String(jtv)
}
case "AutoMinorVersionUpgrade":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value)
}
sv.AutoMinorVersionUpgrade = ptr.Bool(jtv)
}
case "AvailabilityMode":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AZStatus to be of type string, got %T instead", value)
}
sv.AvailabilityMode = types.AZStatus(jtv)
}
case "ClusterEndpoint":
if err := awsAwsjson11_deserializeDocumentEndpoint(&sv.ClusterEndpoint, value); err != nil {
return err
}
case "DataTiering":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DataTieringStatus to be of type string, got %T instead", value)
}
sv.DataTiering = types.DataTieringStatus(jtv)
}
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "EnginePatchVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.EnginePatchVersion = ptr.String(jtv)
}
case "EngineVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.EngineVersion = ptr.String(jtv)
}
case "KmsKeyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.KmsKeyId = ptr.String(jtv)
}
case "MaintenanceWindow":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.MaintenanceWindow = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "NodeType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.NodeType = ptr.String(jtv)
}
case "NumberOfShards":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected IntegerOptional to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.NumberOfShards = ptr.Int32(int32(i64))
}
case "ParameterGroupName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ParameterGroupName = ptr.String(jtv)
}
case "ParameterGroupStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ParameterGroupStatus = ptr.String(jtv)
}
case "PendingUpdates":
if err := awsAwsjson11_deserializeDocumentClusterPendingUpdates(&sv.PendingUpdates, value); err != nil {
return err
}
case "SecurityGroups":
if err := awsAwsjson11_deserializeDocumentSecurityGroupMembershipList(&sv.SecurityGroups, value); err != nil {
return err
}
case "Shards":
if err := awsAwsjson11_deserializeDocumentShardList(&sv.Shards, value); err != nil {
return err
}
case "SnapshotRetentionLimit":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected IntegerOptional to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.SnapshotRetentionLimit = ptr.Int32(int32(i64))
}
case "SnapshotWindow":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.SnapshotWindow = ptr.String(jtv)
}
case "SnsTopicArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.SnsTopicArn = ptr.String(jtv)
}
case "SnsTopicStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.SnsTopicStatus = ptr.String(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Status = ptr.String(jtv)
}
case "SubnetGroupName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.SubnetGroupName = ptr.String(jtv)
}
case "TLSEnabled":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected BooleanOptional to be of type *bool, got %T instead", value)
}
sv.TLSEnabled = ptr.Bool(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentClusterAlreadyExistsFault(v **types.ClusterAlreadyExistsFault, 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.ClusterAlreadyExistsFault
if *v == nil {
sv = &types.ClusterAlreadyExistsFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentClusterConfiguration(v **types.ClusterConfiguration, 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.ClusterConfiguration
if *v == nil {
sv = &types.ClusterConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "EngineVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.EngineVersion = ptr.String(jtv)
}
case "MaintenanceWindow":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.MaintenanceWindow = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "NodeType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.NodeType = ptr.String(jtv)
}
case "NumShards":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected IntegerOptional to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.NumShards = ptr.Int32(int32(i64))
}
case "ParameterGroupName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ParameterGroupName = ptr.String(jtv)
}
case "Port":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected IntegerOptional to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Port = ptr.Int32(int32(i64))
}
case "Shards":
if err := awsAwsjson11_deserializeDocumentShardDetails(&sv.Shards, value); err != nil {
return err
}
case "SnapshotRetentionLimit":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected IntegerOptional to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.SnapshotRetentionLimit = ptr.Int32(int32(i64))
}
case "SnapshotWindow":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.SnapshotWindow = ptr.String(jtv)
}
case "SubnetGroupName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.SubnetGroupName = ptr.String(jtv)
}
case "TopicArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.TopicArn = ptr.String(jtv)
}
case "VpcId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.VpcId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentClusterList(v *[]types.Cluster, 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.Cluster
if *v == nil {
cv = []types.Cluster{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Cluster
destAddr := &col
if err := awsAwsjson11_deserializeDocumentCluster(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentClusterNotFoundFault(v **types.ClusterNotFoundFault, 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.ClusterNotFoundFault
if *v == nil {
sv = &types.ClusterNotFoundFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentClusterPendingUpdates(v **types.ClusterPendingUpdates, 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.ClusterPendingUpdates
if *v == nil {
sv = &types.ClusterPendingUpdates{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ACLs":
if err := awsAwsjson11_deserializeDocumentACLsUpdateStatus(&sv.ACLs, value); err != nil {
return err
}
case "Resharding":
if err := awsAwsjson11_deserializeDocumentReshardingStatus(&sv.Resharding, value); err != nil {
return err
}
case "ServiceUpdates":
if err := awsAwsjson11_deserializeDocumentPendingModifiedServiceUpdateList(&sv.ServiceUpdates, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentClusterQuotaForCustomerExceededFault(v **types.ClusterQuotaForCustomerExceededFault, 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.ClusterQuotaForCustomerExceededFault
if *v == nil {
sv = &types.ClusterQuotaForCustomerExceededFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentDefaultUserRequired(v **types.DefaultUserRequired, 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.DefaultUserRequired
if *v == nil {
sv = &types.DefaultUserRequired{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentDuplicateUserNameFault(v **types.DuplicateUserNameFault, 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.DuplicateUserNameFault
if *v == nil {
sv = &types.DuplicateUserNameFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentEndpoint(v **types.Endpoint, 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.Endpoint
if *v == nil {
sv = &types.Endpoint{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Address":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Address = ptr.String(jtv)
}
case "Port":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Port = int32(i64)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentEngineVersionInfo(v **types.EngineVersionInfo, 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.EngineVersionInfo
if *v == nil {
sv = &types.EngineVersionInfo{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "EnginePatchVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.EnginePatchVersion = ptr.String(jtv)
}
case "EngineVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.EngineVersion = ptr.String(jtv)
}
case "ParameterGroupFamily":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ParameterGroupFamily = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentEngineVersionInfoList(v *[]types.EngineVersionInfo, 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.EngineVersionInfo
if *v == nil {
cv = []types.EngineVersionInfo{}
} else {
cv = *v
}
for _, value := range shape {
var col types.EngineVersionInfo
destAddr := &col
if err := awsAwsjson11_deserializeDocumentEngineVersionInfo(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_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 "Date":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.Date = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value)
}
}
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
case "SourceName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.SourceName = ptr.String(jtv)
}
case "SourceType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SourceType to be of type string, got %T instead", value)
}
sv.SourceType = types.SourceType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentEventList(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 := awsAwsjson11_deserializeDocumentEvent(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentInsufficientClusterCapacityFault(v **types.InsufficientClusterCapacityFault, 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.InsufficientClusterCapacityFault
if *v == nil {
sv = &types.InsufficientClusterCapacityFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInvalidACLStateFault(v **types.InvalidACLStateFault, 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.InvalidACLStateFault
if *v == nil {
sv = &types.InvalidACLStateFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInvalidARNFault(v **types.InvalidARNFault, 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.InvalidARNFault
if *v == nil {
sv = &types.InvalidARNFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInvalidClusterStateFault(v **types.InvalidClusterStateFault, 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.InvalidClusterStateFault
if *v == nil {
sv = &types.InvalidClusterStateFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInvalidCredentialsException(v **types.InvalidCredentialsException, 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.InvalidCredentialsException
if *v == nil {
sv = &types.InvalidCredentialsException{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInvalidKMSKeyFault(v **types.InvalidKMSKeyFault, 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.InvalidKMSKeyFault
if *v == nil {
sv = &types.InvalidKMSKeyFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInvalidNodeStateFault(v **types.InvalidNodeStateFault, 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.InvalidNodeStateFault
if *v == nil {
sv = &types.InvalidNodeStateFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInvalidParameterCombinationException(v **types.InvalidParameterCombinationException, 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.InvalidParameterCombinationException
if *v == nil {
sv = &types.InvalidParameterCombinationException{}
} 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 AwsQueryErrorMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInvalidParameterGroupStateFault(v **types.InvalidParameterGroupStateFault, 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.InvalidParameterGroupStateFault
if *v == nil {
sv = &types.InvalidParameterGroupStateFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInvalidParameterValueException(v **types.InvalidParameterValueException, 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.InvalidParameterValueException
if *v == nil {
sv = &types.InvalidParameterValueException{}
} 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 AwsQueryErrorMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInvalidSnapshotStateFault(v **types.InvalidSnapshotStateFault, 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.InvalidSnapshotStateFault
if *v == nil {
sv = &types.InvalidSnapshotStateFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInvalidSubnet(v **types.InvalidSubnet, 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.InvalidSubnet
if *v == nil {
sv = &types.InvalidSubnet{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInvalidUserStateFault(v **types.InvalidUserStateFault, 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.InvalidUserStateFault
if *v == nil {
sv = &types.InvalidUserStateFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInvalidVPCNetworkStateFault(v **types.InvalidVPCNetworkStateFault, 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.InvalidVPCNetworkStateFault
if *v == nil {
sv = &types.InvalidVPCNetworkStateFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNode(v **types.Node, 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.Node
if *v == nil {
sv = &types.Node{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AvailabilityZone":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.AvailabilityZone = ptr.String(jtv)
}
case "CreateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value)
}
}
case "Endpoint":
if err := awsAwsjson11_deserializeDocumentEndpoint(&sv.Endpoint, value); err != nil {
return err
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Status = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNodeList(v *[]types.Node, 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.Node
if *v == nil {
cv = []types.Node{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Node
destAddr := &col
if err := awsAwsjson11_deserializeDocumentNode(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentNodeQuotaForClusterExceededFault(v **types.NodeQuotaForClusterExceededFault, 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.NodeQuotaForClusterExceededFault
if *v == nil {
sv = &types.NodeQuotaForClusterExceededFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNodeQuotaForCustomerExceededFault(v **types.NodeQuotaForCustomerExceededFault, 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.NodeQuotaForCustomerExceededFault
if *v == nil {
sv = &types.NodeQuotaForCustomerExceededFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNodeTypeList(v *[]string, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []string
if *v == nil {
cv = []string{}
} else {
cv = *v
}
for _, value := range shape {
var col string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentNoOperationFault(v **types.NoOperationFault, 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.NoOperationFault
if *v == nil {
sv = &types.NoOperationFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentParameter(v **types.Parameter, 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.Parameter
if *v == nil {
sv = &types.Parameter{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AllowedValues":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.AllowedValues = ptr.String(jtv)
}
case "DataType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.DataType = ptr.String(jtv)
}
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "MinimumEngineVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.MinimumEngineVersion = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "Value":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Value = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentParameterGroup(v **types.ParameterGroup, 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.ParameterGroup
if *v == nil {
sv = &types.ParameterGroup{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ARN":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ARN = ptr.String(jtv)
}
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "Family":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Family = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentParameterGroupAlreadyExistsFault(v **types.ParameterGroupAlreadyExistsFault, 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.ParameterGroupAlreadyExistsFault
if *v == nil {
sv = &types.ParameterGroupAlreadyExistsFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentParameterGroupList(v *[]types.ParameterGroup, 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.ParameterGroup
if *v == nil {
cv = []types.ParameterGroup{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ParameterGroup
destAddr := &col
if err := awsAwsjson11_deserializeDocumentParameterGroup(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentParameterGroupNotFoundFault(v **types.ParameterGroupNotFoundFault, 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.ParameterGroupNotFoundFault
if *v == nil {
sv = &types.ParameterGroupNotFoundFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentParameterGroupQuotaExceededFault(v **types.ParameterGroupQuotaExceededFault, 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.ParameterGroupQuotaExceededFault
if *v == nil {
sv = &types.ParameterGroupQuotaExceededFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentParametersList(v *[]types.Parameter, 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.Parameter
if *v == nil {
cv = []types.Parameter{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Parameter
destAddr := &col
if err := awsAwsjson11_deserializeDocumentParameter(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentPendingModifiedServiceUpdate(v **types.PendingModifiedServiceUpdate, 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.PendingModifiedServiceUpdate
if *v == nil {
sv = &types.PendingModifiedServiceUpdate{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ServiceUpdateName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ServiceUpdateName = ptr.String(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ServiceUpdateStatus to be of type string, got %T instead", value)
}
sv.Status = types.ServiceUpdateStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentPendingModifiedServiceUpdateList(v *[]types.PendingModifiedServiceUpdate, 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.PendingModifiedServiceUpdate
if *v == nil {
cv = []types.PendingModifiedServiceUpdate{}
} else {
cv = *v
}
for _, value := range shape {
var col types.PendingModifiedServiceUpdate
destAddr := &col
if err := awsAwsjson11_deserializeDocumentPendingModifiedServiceUpdate(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentRecurringCharge(v **types.RecurringCharge, 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.RecurringCharge
if *v == nil {
sv = &types.RecurringCharge{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "RecurringChargeAmount":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.RecurringChargeAmount = f64
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.RecurringChargeAmount = f64
default:
return fmt.Errorf("expected Double to be a JSON Number, got %T instead", value)
}
}
case "RecurringChargeFrequency":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.RecurringChargeFrequency = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentRecurringChargeList(v *[]types.RecurringCharge, 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.RecurringCharge
if *v == nil {
cv = []types.RecurringCharge{}
} else {
cv = *v
}
for _, value := range shape {
var col types.RecurringCharge
destAddr := &col
if err := awsAwsjson11_deserializeDocumentRecurringCharge(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentReservedNode(v **types.ReservedNode, 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.ReservedNode
if *v == nil {
sv = &types.ReservedNode{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ARN":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ARN = ptr.String(jtv)
}
case "Duration":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Duration = int32(i64)
}
case "FixedPrice":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.FixedPrice = f64
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.FixedPrice = f64
default:
return fmt.Errorf("expected Double to be a JSON Number, got %T instead", value)
}
}
case "NodeCount":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.NodeCount = int32(i64)
}
case "NodeType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.NodeType = ptr.String(jtv)
}
case "OfferingType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.OfferingType = ptr.String(jtv)
}
case "RecurringCharges":
if err := awsAwsjson11_deserializeDocumentRecurringChargeList(&sv.RecurringCharges, value); err != nil {
return err
}
case "ReservationId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ReservationId = ptr.String(jtv)
}
case "ReservedNodesOfferingId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ReservedNodesOfferingId = 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 TStamp to be a JSON Number, got %T instead", value)
}
}
case "State":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.State = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentReservedNodeAlreadyExistsFault(v **types.ReservedNodeAlreadyExistsFault, 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.ReservedNodeAlreadyExistsFault
if *v == nil {
sv = &types.ReservedNodeAlreadyExistsFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentReservedNodeList(v *[]types.ReservedNode, 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.ReservedNode
if *v == nil {
cv = []types.ReservedNode{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ReservedNode
destAddr := &col
if err := awsAwsjson11_deserializeDocumentReservedNode(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentReservedNodeNotFoundFault(v **types.ReservedNodeNotFoundFault, 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.ReservedNodeNotFoundFault
if *v == nil {
sv = &types.ReservedNodeNotFoundFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentReservedNodeQuotaExceededFault(v **types.ReservedNodeQuotaExceededFault, 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.ReservedNodeQuotaExceededFault
if *v == nil {
sv = &types.ReservedNodeQuotaExceededFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentReservedNodesOffering(v **types.ReservedNodesOffering, 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.ReservedNodesOffering
if *v == nil {
sv = &types.ReservedNodesOffering{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Duration":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Integer to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Duration = int32(i64)
}
case "FixedPrice":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.FixedPrice = f64
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.FixedPrice = f64
default:
return fmt.Errorf("expected Double to be a JSON Number, got %T instead", value)
}
}
case "NodeType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.NodeType = ptr.String(jtv)
}
case "OfferingType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.OfferingType = ptr.String(jtv)
}
case "RecurringCharges":
if err := awsAwsjson11_deserializeDocumentRecurringChargeList(&sv.RecurringCharges, value); err != nil {
return err
}
case "ReservedNodesOfferingId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ReservedNodesOfferingId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentReservedNodesOfferingList(v *[]types.ReservedNodesOffering, 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.ReservedNodesOffering
if *v == nil {
cv = []types.ReservedNodesOffering{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ReservedNodesOffering
destAddr := &col
if err := awsAwsjson11_deserializeDocumentReservedNodesOffering(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentReservedNodesOfferingNotFoundFault(v **types.ReservedNodesOfferingNotFoundFault, 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.ReservedNodesOfferingNotFoundFault
if *v == nil {
sv = &types.ReservedNodesOfferingNotFoundFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentReshardingStatus(v **types.ReshardingStatus, 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.ReshardingStatus
if *v == nil {
sv = &types.ReshardingStatus{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "SlotMigration":
if err := awsAwsjson11_deserializeDocumentSlotMigration(&sv.SlotMigration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentSecurityGroupMembership(v **types.SecurityGroupMembership, 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.SecurityGroupMembership
if *v == nil {
sv = &types.SecurityGroupMembership{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "SecurityGroupId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.SecurityGroupId = ptr.String(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Status = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentSecurityGroupMembershipList(v *[]types.SecurityGroupMembership, 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.SecurityGroupMembership
if *v == nil {
cv = []types.SecurityGroupMembership{}
} else {
cv = *v
}
for _, value := range shape {
var col types.SecurityGroupMembership
destAddr := &col
if err := awsAwsjson11_deserializeDocumentSecurityGroupMembership(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentServiceLinkedRoleNotFoundFault(v **types.ServiceLinkedRoleNotFoundFault, 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.ServiceLinkedRoleNotFoundFault
if *v == nil {
sv = &types.ServiceLinkedRoleNotFoundFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentServiceUpdate(v **types.ServiceUpdate, 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.ServiceUpdate
if *v == nil {
sv = &types.ServiceUpdate{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AutoUpdateStartDate":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.AutoUpdateStartDate = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value)
}
}
case "ClusterName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ClusterName = ptr.String(jtv)
}
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "NodesUpdated":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.NodesUpdated = ptr.String(jtv)
}
case "ReleaseDate":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.ReleaseDate = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value)
}
}
case "ServiceUpdateName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ServiceUpdateName = ptr.String(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ServiceUpdateStatus to be of type string, got %T instead", value)
}
sv.Status = types.ServiceUpdateStatus(jtv)
}
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ServiceUpdateType to be of type string, got %T instead", value)
}
sv.Type = types.ServiceUpdateType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentServiceUpdateList(v *[]types.ServiceUpdate, 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.ServiceUpdate
if *v == nil {
cv = []types.ServiceUpdate{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ServiceUpdate
destAddr := &col
if err := awsAwsjson11_deserializeDocumentServiceUpdate(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentServiceUpdateNotFoundFault(v **types.ServiceUpdateNotFoundFault, 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.ServiceUpdateNotFoundFault
if *v == nil {
sv = &types.ServiceUpdateNotFoundFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentShard(v **types.Shard, 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.Shard
if *v == nil {
sv = &types.Shard{}
} 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 String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "Nodes":
if err := awsAwsjson11_deserializeDocumentNodeList(&sv.Nodes, value); err != nil {
return err
}
case "NumberOfNodes":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected IntegerOptional to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.NumberOfNodes = ptr.Int32(int32(i64))
}
case "Slots":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Slots = ptr.String(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Status = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentShardConfiguration(v **types.ShardConfiguration, 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.ShardConfiguration
if *v == nil {
sv = &types.ShardConfiguration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ReplicaCount":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected IntegerOptional to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.ReplicaCount = ptr.Int32(int32(i64))
}
case "Slots":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Slots = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentShardDetail(v **types.ShardDetail, 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.ShardDetail
if *v == nil {
sv = &types.ShardDetail{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Configuration":
if err := awsAwsjson11_deserializeDocumentShardConfiguration(&sv.Configuration, value); err != nil {
return err
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "Size":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Size = ptr.String(jtv)
}
case "SnapshotCreationTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.SnapshotCreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected TStamp to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentShardDetails(v *[]types.ShardDetail, 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.ShardDetail
if *v == nil {
cv = []types.ShardDetail{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ShardDetail
destAddr := &col
if err := awsAwsjson11_deserializeDocumentShardDetail(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentShardList(v *[]types.Shard, 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.Shard
if *v == nil {
cv = []types.Shard{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Shard
destAddr := &col
if err := awsAwsjson11_deserializeDocumentShard(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentShardNotFoundFault(v **types.ShardNotFoundFault, 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.ShardNotFoundFault
if *v == nil {
sv = &types.ShardNotFoundFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentShardsPerClusterQuotaExceededFault(v **types.ShardsPerClusterQuotaExceededFault, 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.ShardsPerClusterQuotaExceededFault
if *v == nil {
sv = &types.ShardsPerClusterQuotaExceededFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentSlotMigration(v **types.SlotMigration, 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.SlotMigration
if *v == nil {
sv = &types.SlotMigration{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ProgressPercentage":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.ProgressPercentage = f64
case string:
var f64 float64
switch {
case strings.EqualFold(jtv, "NaN"):
f64 = math.NaN()
case strings.EqualFold(jtv, "Infinity"):
f64 = math.Inf(1)
case strings.EqualFold(jtv, "-Infinity"):
f64 = math.Inf(-1)
default:
return fmt.Errorf("unknown JSON number value: %s", jtv)
}
sv.ProgressPercentage = f64
default:
return fmt.Errorf("expected Double to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentSnapshot(v **types.Snapshot, 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.Snapshot
if *v == nil {
sv = &types.Snapshot{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ARN":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ARN = ptr.String(jtv)
}
case "ClusterConfiguration":
if err := awsAwsjson11_deserializeDocumentClusterConfiguration(&sv.ClusterConfiguration, value); err != nil {
return err
}
case "DataTiering":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DataTieringStatus to be of type string, got %T instead", value)
}
sv.DataTiering = types.DataTieringStatus(jtv)
}
case "KmsKeyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.KmsKeyId = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "Source":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Source = ptr.String(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Status = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentSnapshotAlreadyExistsFault(v **types.SnapshotAlreadyExistsFault, 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.SnapshotAlreadyExistsFault
if *v == nil {
sv = &types.SnapshotAlreadyExistsFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentSnapshotList(v *[]types.Snapshot, 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.Snapshot
if *v == nil {
cv = []types.Snapshot{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Snapshot
destAddr := &col
if err := awsAwsjson11_deserializeDocumentSnapshot(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentSnapshotNotFoundFault(v **types.SnapshotNotFoundFault, 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.SnapshotNotFoundFault
if *v == nil {
sv = &types.SnapshotNotFoundFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentSnapshotQuotaExceededFault(v **types.SnapshotQuotaExceededFault, 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.SnapshotQuotaExceededFault
if *v == nil {
sv = &types.SnapshotQuotaExceededFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentSubnet(v **types.Subnet, 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.Subnet
if *v == nil {
sv = &types.Subnet{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AvailabilityZone":
if err := awsAwsjson11_deserializeDocumentAvailabilityZone(&sv.AvailabilityZone, value); err != nil {
return err
}
case "Identifier":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Identifier = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentSubnetGroup(v **types.SubnetGroup, 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.SubnetGroup
if *v == nil {
sv = &types.SubnetGroup{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ARN":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ARN = ptr.String(jtv)
}
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "Subnets":
if err := awsAwsjson11_deserializeDocumentSubnetList(&sv.Subnets, value); err != nil {
return err
}
case "VpcId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.VpcId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentSubnetGroupAlreadyExistsFault(v **types.SubnetGroupAlreadyExistsFault, 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.SubnetGroupAlreadyExistsFault
if *v == nil {
sv = &types.SubnetGroupAlreadyExistsFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentSubnetGroupInUseFault(v **types.SubnetGroupInUseFault, 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.SubnetGroupInUseFault
if *v == nil {
sv = &types.SubnetGroupInUseFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentSubnetGroupList(v *[]types.SubnetGroup, 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.SubnetGroup
if *v == nil {
cv = []types.SubnetGroup{}
} else {
cv = *v
}
for _, value := range shape {
var col types.SubnetGroup
destAddr := &col
if err := awsAwsjson11_deserializeDocumentSubnetGroup(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentSubnetGroupNotFoundFault(v **types.SubnetGroupNotFoundFault, 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.SubnetGroupNotFoundFault
if *v == nil {
sv = &types.SubnetGroupNotFoundFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentSubnetGroupQuotaExceededFault(v **types.SubnetGroupQuotaExceededFault, 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.SubnetGroupQuotaExceededFault
if *v == nil {
sv = &types.SubnetGroupQuotaExceededFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentSubnetInUse(v **types.SubnetInUse, 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.SubnetInUse
if *v == nil {
sv = &types.SubnetInUse{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentSubnetList(v *[]types.Subnet, 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.Subnet
if *v == nil {
cv = []types.Subnet{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Subnet
destAddr := &col
if err := awsAwsjson11_deserializeDocumentSubnet(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentSubnetNotAllowedFault(v **types.SubnetNotAllowedFault, 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.SubnetNotAllowedFault
if *v == nil {
sv = &types.SubnetNotAllowedFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentSubnetQuotaExceededFault(v **types.SubnetQuotaExceededFault, 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.SubnetQuotaExceededFault
if *v == nil {
sv = &types.SubnetQuotaExceededFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_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 String 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 String to be of type string, got %T instead", value)
}
sv.Value = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentTagList(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 := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentTagNotFoundFault(v **types.TagNotFoundFault, 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.TagNotFoundFault
if *v == nil {
sv = &types.TagNotFoundFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentTagQuotaPerResourceExceeded(v **types.TagQuotaPerResourceExceeded, 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.TagQuotaPerResourceExceeded
if *v == nil {
sv = &types.TagQuotaPerResourceExceeded{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentTestFailoverNotAvailableFault(v **types.TestFailoverNotAvailableFault, 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.TestFailoverNotAvailableFault
if *v == nil {
sv = &types.TestFailoverNotAvailableFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentUnprocessedCluster(v **types.UnprocessedCluster, 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.UnprocessedCluster
if *v == nil {
sv = &types.UnprocessedCluster{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ClusterName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ClusterName = ptr.String(jtv)
}
case "ErrorMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ErrorMessage = ptr.String(jtv)
}
case "ErrorType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ErrorType = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentUnprocessedClusterList(v *[]types.UnprocessedCluster, 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.UnprocessedCluster
if *v == nil {
cv = []types.UnprocessedCluster{}
} else {
cv = *v
}
for _, value := range shape {
var col types.UnprocessedCluster
destAddr := &col
if err := awsAwsjson11_deserializeDocumentUnprocessedCluster(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentUser(v **types.User, 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.User
if *v == nil {
sv = &types.User{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AccessString":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.AccessString = ptr.String(jtv)
}
case "ACLNames":
if err := awsAwsjson11_deserializeDocumentACLNameList(&sv.ACLNames, value); err != nil {
return err
}
case "ARN":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ARN = ptr.String(jtv)
}
case "Authentication":
if err := awsAwsjson11_deserializeDocumentAuthentication(&sv.Authentication, value); err != nil {
return err
}
case "MinimumEngineVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.MinimumEngineVersion = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Status = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentUserAlreadyExistsFault(v **types.UserAlreadyExistsFault, 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.UserAlreadyExistsFault
if *v == nil {
sv = &types.UserAlreadyExistsFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentUserList(v *[]types.User, 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.User
if *v == nil {
cv = []types.User{}
} else {
cv = *v
}
for _, value := range shape {
var col types.User
destAddr := &col
if err := awsAwsjson11_deserializeDocumentUser(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentUserNameList(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 UserName to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentUserNotFoundFault(v **types.UserNotFoundFault, 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.UserNotFoundFault
if *v == nil {
sv = &types.UserNotFoundFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentUserQuotaExceededFault(v **types.UserQuotaExceededFault, 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.UserQuotaExceededFault
if *v == nil {
sv = &types.UserQuotaExceededFault{}
} 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 ExceptionMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentBatchUpdateClusterOutput(v **BatchUpdateClusterOutput, 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 *BatchUpdateClusterOutput
if *v == nil {
sv = &BatchUpdateClusterOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ProcessedClusters":
if err := awsAwsjson11_deserializeDocumentClusterList(&sv.ProcessedClusters, value); err != nil {
return err
}
case "UnprocessedClusters":
if err := awsAwsjson11_deserializeDocumentUnprocessedClusterList(&sv.UnprocessedClusters, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentCopySnapshotOutput(v **CopySnapshotOutput, 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 *CopySnapshotOutput
if *v == nil {
sv = &CopySnapshotOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Snapshot":
if err := awsAwsjson11_deserializeDocumentSnapshot(&sv.Snapshot, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentCreateACLOutput(v **CreateACLOutput, 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 *CreateACLOutput
if *v == nil {
sv = &CreateACLOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ACL":
if err := awsAwsjson11_deserializeDocumentACL(&sv.ACL, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentCreateClusterOutput(v **CreateClusterOutput, 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 *CreateClusterOutput
if *v == nil {
sv = &CreateClusterOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Cluster":
if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentCreateParameterGroupOutput(v **CreateParameterGroupOutput, 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 *CreateParameterGroupOutput
if *v == nil {
sv = &CreateParameterGroupOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ParameterGroup":
if err := awsAwsjson11_deserializeDocumentParameterGroup(&sv.ParameterGroup, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentCreateSnapshotOutput(v **CreateSnapshotOutput, 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 *CreateSnapshotOutput
if *v == nil {
sv = &CreateSnapshotOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Snapshot":
if err := awsAwsjson11_deserializeDocumentSnapshot(&sv.Snapshot, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentCreateSubnetGroupOutput(v **CreateSubnetGroupOutput, 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 *CreateSubnetGroupOutput
if *v == nil {
sv = &CreateSubnetGroupOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "SubnetGroup":
if err := awsAwsjson11_deserializeDocumentSubnetGroup(&sv.SubnetGroup, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentCreateUserOutput(v **CreateUserOutput, 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 *CreateUserOutput
if *v == nil {
sv = &CreateUserOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "User":
if err := awsAwsjson11_deserializeDocumentUser(&sv.User, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDeleteACLOutput(v **DeleteACLOutput, 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 *DeleteACLOutput
if *v == nil {
sv = &DeleteACLOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ACL":
if err := awsAwsjson11_deserializeDocumentACL(&sv.ACL, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDeleteClusterOutput(v **DeleteClusterOutput, 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 *DeleteClusterOutput
if *v == nil {
sv = &DeleteClusterOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Cluster":
if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDeleteParameterGroupOutput(v **DeleteParameterGroupOutput, 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 *DeleteParameterGroupOutput
if *v == nil {
sv = &DeleteParameterGroupOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ParameterGroup":
if err := awsAwsjson11_deserializeDocumentParameterGroup(&sv.ParameterGroup, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDeleteSnapshotOutput(v **DeleteSnapshotOutput, 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 *DeleteSnapshotOutput
if *v == nil {
sv = &DeleteSnapshotOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Snapshot":
if err := awsAwsjson11_deserializeDocumentSnapshot(&sv.Snapshot, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDeleteSubnetGroupOutput(v **DeleteSubnetGroupOutput, 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 *DeleteSubnetGroupOutput
if *v == nil {
sv = &DeleteSubnetGroupOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "SubnetGroup":
if err := awsAwsjson11_deserializeDocumentSubnetGroup(&sv.SubnetGroup, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDeleteUserOutput(v **DeleteUserOutput, 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 *DeleteUserOutput
if *v == nil {
sv = &DeleteUserOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "User":
if err := awsAwsjson11_deserializeDocumentUser(&sv.User, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeACLsOutput(v **DescribeACLsOutput, 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 *DescribeACLsOutput
if *v == nil {
sv = &DescribeACLsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ACLs":
if err := awsAwsjson11_deserializeDocumentACLList(&sv.ACLs, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeClustersOutput(v **DescribeClustersOutput, 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 *DescribeClustersOutput
if *v == nil {
sv = &DescribeClustersOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Clusters":
if err := awsAwsjson11_deserializeDocumentClusterList(&sv.Clusters, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeEngineVersionsOutput(v **DescribeEngineVersionsOutput, 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 *DescribeEngineVersionsOutput
if *v == nil {
sv = &DescribeEngineVersionsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "EngineVersions":
if err := awsAwsjson11_deserializeDocumentEngineVersionInfoList(&sv.EngineVersions, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeEventsOutput(v **DescribeEventsOutput, 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 *DescribeEventsOutput
if *v == nil {
sv = &DescribeEventsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Events":
if err := awsAwsjson11_deserializeDocumentEventList(&sv.Events, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeParameterGroupsOutput(v **DescribeParameterGroupsOutput, 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 *DescribeParameterGroupsOutput
if *v == nil {
sv = &DescribeParameterGroupsOutput{}
} 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 String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "ParameterGroups":
if err := awsAwsjson11_deserializeDocumentParameterGroupList(&sv.ParameterGroups, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeParametersOutput(v **DescribeParametersOutput, 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 *DescribeParametersOutput
if *v == nil {
sv = &DescribeParametersOutput{}
} 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 String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "Parameters":
if err := awsAwsjson11_deserializeDocumentParametersList(&sv.Parameters, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeReservedNodesOfferingsOutput(v **DescribeReservedNodesOfferingsOutput, 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 *DescribeReservedNodesOfferingsOutput
if *v == nil {
sv = &DescribeReservedNodesOfferingsOutput{}
} 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 String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "ReservedNodesOfferings":
if err := awsAwsjson11_deserializeDocumentReservedNodesOfferingList(&sv.ReservedNodesOfferings, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeReservedNodesOutput(v **DescribeReservedNodesOutput, 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 *DescribeReservedNodesOutput
if *v == nil {
sv = &DescribeReservedNodesOutput{}
} 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 String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "ReservedNodes":
if err := awsAwsjson11_deserializeDocumentReservedNodeList(&sv.ReservedNodes, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeServiceUpdatesOutput(v **DescribeServiceUpdatesOutput, 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 *DescribeServiceUpdatesOutput
if *v == nil {
sv = &DescribeServiceUpdatesOutput{}
} 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 String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "ServiceUpdates":
if err := awsAwsjson11_deserializeDocumentServiceUpdateList(&sv.ServiceUpdates, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeSnapshotsOutput(v **DescribeSnapshotsOutput, 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 *DescribeSnapshotsOutput
if *v == nil {
sv = &DescribeSnapshotsOutput{}
} 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 String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "Snapshots":
if err := awsAwsjson11_deserializeDocumentSnapshotList(&sv.Snapshots, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeSubnetGroupsOutput(v **DescribeSubnetGroupsOutput, 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 *DescribeSubnetGroupsOutput
if *v == nil {
sv = &DescribeSubnetGroupsOutput{}
} 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 String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "SubnetGroups":
if err := awsAwsjson11_deserializeDocumentSubnetGroupList(&sv.SubnetGroups, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDescribeUsersOutput(v **DescribeUsersOutput, 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 *DescribeUsersOutput
if *v == nil {
sv = &DescribeUsersOutput{}
} 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 String to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "Users":
if err := awsAwsjson11_deserializeDocumentUserList(&sv.Users, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentFailoverShardOutput(v **FailoverShardOutput, 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 *FailoverShardOutput
if *v == nil {
sv = &FailoverShardOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Cluster":
if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentListAllowedNodeTypeUpdatesOutput(v **ListAllowedNodeTypeUpdatesOutput, 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 *ListAllowedNodeTypeUpdatesOutput
if *v == nil {
sv = &ListAllowedNodeTypeUpdatesOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ScaleDownNodeTypes":
if err := awsAwsjson11_deserializeDocumentNodeTypeList(&sv.ScaleDownNodeTypes, value); err != nil {
return err
}
case "ScaleUpNodeTypes":
if err := awsAwsjson11_deserializeDocumentNodeTypeList(&sv.ScaleUpNodeTypes, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentListTagsOutput(v **ListTagsOutput, 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 *ListTagsOutput
if *v == nil {
sv = &ListTagsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "TagList":
if err := awsAwsjson11_deserializeDocumentTagList(&sv.TagList, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentPurchaseReservedNodesOfferingOutput(v **PurchaseReservedNodesOfferingOutput, 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 *PurchaseReservedNodesOfferingOutput
if *v == nil {
sv = &PurchaseReservedNodesOfferingOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ReservedNode":
if err := awsAwsjson11_deserializeDocumentReservedNode(&sv.ReservedNode, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentResetParameterGroupOutput(v **ResetParameterGroupOutput, 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 *ResetParameterGroupOutput
if *v == nil {
sv = &ResetParameterGroupOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ParameterGroup":
if err := awsAwsjson11_deserializeDocumentParameterGroup(&sv.ParameterGroup, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, 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 *TagResourceOutput
if *v == nil {
sv = &TagResourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "TagList":
if err := awsAwsjson11_deserializeDocumentTagList(&sv.TagList, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, 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 *UntagResourceOutput
if *v == nil {
sv = &UntagResourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "TagList":
if err := awsAwsjson11_deserializeDocumentTagList(&sv.TagList, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentUpdateACLOutput(v **UpdateACLOutput, 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 *UpdateACLOutput
if *v == nil {
sv = &UpdateACLOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ACL":
if err := awsAwsjson11_deserializeDocumentACL(&sv.ACL, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentUpdateClusterOutput(v **UpdateClusterOutput, 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 *UpdateClusterOutput
if *v == nil {
sv = &UpdateClusterOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Cluster":
if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentUpdateParameterGroupOutput(v **UpdateParameterGroupOutput, 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 *UpdateParameterGroupOutput
if *v == nil {
sv = &UpdateParameterGroupOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ParameterGroup":
if err := awsAwsjson11_deserializeDocumentParameterGroup(&sv.ParameterGroup, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentUpdateSubnetGroupOutput(v **UpdateSubnetGroupOutput, 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 *UpdateSubnetGroupOutput
if *v == nil {
sv = &UpdateSubnetGroupOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "SubnetGroup":
if err := awsAwsjson11_deserializeDocumentSubnetGroup(&sv.SubnetGroup, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentUpdateUserOutput(v **UpdateUserOutput, 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 *UpdateUserOutput
if *v == nil {
sv = &UpdateUserOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "User":
if err := awsAwsjson11_deserializeDocumentUser(&sv.User, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
| 13,495 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package memorydb provides the API client, operations, and parameter types for
// Amazon MemoryDB.
//
// MemoryDB for Redis is a fully managed, Redis-compatible, in-memory database
// that delivers ultra-fast performance and Multi-AZ durability for modern
// applications built using microservices architectures. MemoryDB stores the entire
// database in-memory, enabling low latency and high throughput data access. It is
// compatible with Redis, a popular open source data store, enabling you to
// leverage Redis’ flexible and friendly data structures, APIs, and commands.
package memorydb
| 13 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
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/memorydb/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 = "memorydb"
}
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 memorydb
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.13.2"
| 7 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
import (
"bytes"
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/memorydb/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/encoding/httpbinding"
smithyjson "github.com/aws/smithy-go/encoding/json"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
"path"
)
type awsAwsjson11_serializeOpBatchUpdateCluster struct {
}
func (*awsAwsjson11_serializeOpBatchUpdateCluster) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpBatchUpdateCluster) 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.(*BatchUpdateClusterInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.BatchUpdateCluster")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentBatchUpdateClusterInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCopySnapshot struct {
}
func (*awsAwsjson11_serializeOpCopySnapshot) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCopySnapshot) 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.(*CopySnapshotInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.CopySnapshot")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCopySnapshotInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateACL struct {
}
func (*awsAwsjson11_serializeOpCreateACL) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateACL) 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.(*CreateACLInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.CreateACL")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateACLInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateCluster struct {
}
func (*awsAwsjson11_serializeOpCreateCluster) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateCluster) 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.(*CreateClusterInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.CreateCluster")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateClusterInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateParameterGroup struct {
}
func (*awsAwsjson11_serializeOpCreateParameterGroup) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateParameterGroup) 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.(*CreateParameterGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.CreateParameterGroup")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateParameterGroupInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateSnapshot struct {
}
func (*awsAwsjson11_serializeOpCreateSnapshot) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateSnapshot) 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.(*CreateSnapshotInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.CreateSnapshot")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateSnapshotInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateSubnetGroup struct {
}
func (*awsAwsjson11_serializeOpCreateSubnetGroup) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateSubnetGroup) 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.(*CreateSubnetGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.CreateSubnetGroup")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateSubnetGroupInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpCreateUser struct {
}
func (*awsAwsjson11_serializeOpCreateUser) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpCreateUser) 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.(*CreateUserInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.CreateUser")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentCreateUserInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteACL struct {
}
func (*awsAwsjson11_serializeOpDeleteACL) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteACL) 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.(*DeleteACLInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DeleteACL")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteACLInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteCluster struct {
}
func (*awsAwsjson11_serializeOpDeleteCluster) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteCluster) 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.(*DeleteClusterInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DeleteCluster")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteClusterInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteParameterGroup struct {
}
func (*awsAwsjson11_serializeOpDeleteParameterGroup) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteParameterGroup) 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.(*DeleteParameterGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DeleteParameterGroup")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteParameterGroupInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteSnapshot struct {
}
func (*awsAwsjson11_serializeOpDeleteSnapshot) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteSnapshot) 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.(*DeleteSnapshotInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DeleteSnapshot")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteSnapshotInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteSubnetGroup struct {
}
func (*awsAwsjson11_serializeOpDeleteSubnetGroup) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteSubnetGroup) 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.(*DeleteSubnetGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DeleteSubnetGroup")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteSubnetGroupInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteUser struct {
}
func (*awsAwsjson11_serializeOpDeleteUser) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteUser) 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.(*DeleteUserInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DeleteUser")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteUserInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeACLs struct {
}
func (*awsAwsjson11_serializeOpDescribeACLs) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeACLs) 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.(*DescribeACLsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeACLs")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeACLsInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeClusters struct {
}
func (*awsAwsjson11_serializeOpDescribeClusters) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeClusters) 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.(*DescribeClustersInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeClusters")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeClustersInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeEngineVersions struct {
}
func (*awsAwsjson11_serializeOpDescribeEngineVersions) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeEngineVersions) 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.(*DescribeEngineVersionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeEngineVersions")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeEngineVersionsInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeEvents struct {
}
func (*awsAwsjson11_serializeOpDescribeEvents) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeEvents) 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.(*DescribeEventsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeEvents")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeEventsInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeParameterGroups struct {
}
func (*awsAwsjson11_serializeOpDescribeParameterGroups) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeParameterGroups) 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.(*DescribeParameterGroupsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeParameterGroups")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeParameterGroupsInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeParameters struct {
}
func (*awsAwsjson11_serializeOpDescribeParameters) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeParameters) 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.(*DescribeParametersInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeParameters")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeParametersInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeReservedNodes struct {
}
func (*awsAwsjson11_serializeOpDescribeReservedNodes) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeReservedNodes) 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.(*DescribeReservedNodesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeReservedNodes")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeReservedNodesInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeReservedNodesOfferings struct {
}
func (*awsAwsjson11_serializeOpDescribeReservedNodesOfferings) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeReservedNodesOfferings) 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.(*DescribeReservedNodesOfferingsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeReservedNodesOfferings")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeReservedNodesOfferingsInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeServiceUpdates struct {
}
func (*awsAwsjson11_serializeOpDescribeServiceUpdates) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeServiceUpdates) 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.(*DescribeServiceUpdatesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeServiceUpdates")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeServiceUpdatesInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeSnapshots struct {
}
func (*awsAwsjson11_serializeOpDescribeSnapshots) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeSnapshots) 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.(*DescribeSnapshotsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeSnapshots")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeSnapshotsInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeSubnetGroups struct {
}
func (*awsAwsjson11_serializeOpDescribeSubnetGroups) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeSubnetGroups) 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.(*DescribeSubnetGroupsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeSubnetGroups")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeSubnetGroupsInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDescribeUsers struct {
}
func (*awsAwsjson11_serializeOpDescribeUsers) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDescribeUsers) 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.(*DescribeUsersInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.DescribeUsers")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDescribeUsersInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpFailoverShard struct {
}
func (*awsAwsjson11_serializeOpFailoverShard) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpFailoverShard) 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.(*FailoverShardInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.FailoverShard")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentFailoverShardInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListAllowedNodeTypeUpdates struct {
}
func (*awsAwsjson11_serializeOpListAllowedNodeTypeUpdates) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListAllowedNodeTypeUpdates) 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.(*ListAllowedNodeTypeUpdatesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.ListAllowedNodeTypeUpdates")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListAllowedNodeTypeUpdatesInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListTags struct {
}
func (*awsAwsjson11_serializeOpListTags) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListTags) 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.(*ListTagsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.ListTags")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListTagsInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpPurchaseReservedNodesOffering struct {
}
func (*awsAwsjson11_serializeOpPurchaseReservedNodesOffering) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpPurchaseReservedNodesOffering) 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.(*PurchaseReservedNodesOfferingInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.PurchaseReservedNodesOffering")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentPurchaseReservedNodesOfferingInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpResetParameterGroup struct {
}
func (*awsAwsjson11_serializeOpResetParameterGroup) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpResetParameterGroup) 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.(*ResetParameterGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.ResetParameterGroup")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentResetParameterGroupInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpTagResource struct {
}
func (*awsAwsjson11_serializeOpTagResource) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_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)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.TagResource")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUntagResource struct {
}
func (*awsAwsjson11_serializeOpUntagResource) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_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)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.UntagResource")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUntagResourceInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateACL struct {
}
func (*awsAwsjson11_serializeOpUpdateACL) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateACL) 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.(*UpdateACLInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.UpdateACL")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateACLInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateCluster struct {
}
func (*awsAwsjson11_serializeOpUpdateCluster) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateCluster) 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.(*UpdateClusterInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.UpdateCluster")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateClusterInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateParameterGroup struct {
}
func (*awsAwsjson11_serializeOpUpdateParameterGroup) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateParameterGroup) 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.(*UpdateParameterGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.UpdateParameterGroup")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateParameterGroupInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateSubnetGroup struct {
}
func (*awsAwsjson11_serializeOpUpdateSubnetGroup) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateSubnetGroup) 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.(*UpdateSubnetGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.UpdateSubnetGroup")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateSubnetGroupInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUpdateUser struct {
}
func (*awsAwsjson11_serializeOpUpdateUser) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUpdateUser) 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.(*UpdateUserInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AmazonMemoryDB.UpdateUser")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUpdateUserInput(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 = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsAwsjson11_serializeDocumentAuthenticationMode(v *types.AuthenticationMode, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Passwords != nil {
ok := object.Key("Passwords")
if err := awsAwsjson11_serializeDocumentPasswordListInput(v.Passwords, ok); err != nil {
return err
}
}
if len(v.Type) > 0 {
ok := object.Key("Type")
ok.String(string(v.Type))
}
return nil
}
func awsAwsjson11_serializeDocumentClusterNameList(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 awsAwsjson11_serializeDocumentFilter(v *types.Filter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if v.Values != nil {
ok := object.Key("Values")
if err := awsAwsjson11_serializeDocumentFilterValueList(v.Values, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentFilterList(v []types.Filter, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsAwsjson11_serializeDocumentFilter(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentFilterValueList(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 awsAwsjson11_serializeDocumentKeyList(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 awsAwsjson11_serializeDocumentParameterNameList(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 awsAwsjson11_serializeDocumentParameterNameValue(v *types.ParameterNameValue, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ParameterName != nil {
ok := object.Key("ParameterName")
ok.String(*v.ParameterName)
}
if v.ParameterValue != nil {
ok := object.Key("ParameterValue")
ok.String(*v.ParameterValue)
}
return nil
}
func awsAwsjson11_serializeDocumentParameterNameValueList(v []types.ParameterNameValue, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsAwsjson11_serializeDocumentParameterNameValue(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentPasswordListInput(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 awsAwsjson11_serializeDocumentReplicaConfigurationRequest(v *types.ReplicaConfigurationRequest, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ReplicaCount != 0 {
ok := object.Key("ReplicaCount")
ok.Integer(v.ReplicaCount)
}
return nil
}
func awsAwsjson11_serializeDocumentSecurityGroupIdsList(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 awsAwsjson11_serializeDocumentServiceUpdateRequest(v *types.ServiceUpdateRequest, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ServiceUpdateNameToApply != nil {
ok := object.Key("ServiceUpdateNameToApply")
ok.String(*v.ServiceUpdateNameToApply)
}
return nil
}
func awsAwsjson11_serializeDocumentServiceUpdateStatusList(v []types.ServiceUpdateStatus, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(string(v[i]))
}
return nil
}
func awsAwsjson11_serializeDocumentShardConfigurationRequest(v *types.ShardConfigurationRequest, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ShardCount != 0 {
ok := object.Key("ShardCount")
ok.Integer(v.ShardCount)
}
return nil
}
func awsAwsjson11_serializeDocumentSnapshotArnsList(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 awsAwsjson11_serializeDocumentSubnetIdentifierList(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 awsAwsjson11_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 awsAwsjson11_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentUserNameListInput(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 awsAwsjson11_serializeOpDocumentBatchUpdateClusterInput(v *BatchUpdateClusterInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClusterNames != nil {
ok := object.Key("ClusterNames")
if err := awsAwsjson11_serializeDocumentClusterNameList(v.ClusterNames, ok); err != nil {
return err
}
}
if v.ServiceUpdate != nil {
ok := object.Key("ServiceUpdate")
if err := awsAwsjson11_serializeDocumentServiceUpdateRequest(v.ServiceUpdate, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentCopySnapshotInput(v *CopySnapshotInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.KmsKeyId != nil {
ok := object.Key("KmsKeyId")
ok.String(*v.KmsKeyId)
}
if v.SourceSnapshotName != nil {
ok := object.Key("SourceSnapshotName")
ok.String(*v.SourceSnapshotName)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
if v.TargetBucket != nil {
ok := object.Key("TargetBucket")
ok.String(*v.TargetBucket)
}
if v.TargetSnapshotName != nil {
ok := object.Key("TargetSnapshotName")
ok.String(*v.TargetSnapshotName)
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateACLInput(v *CreateACLInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ACLName != nil {
ok := object.Key("ACLName")
ok.String(*v.ACLName)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
if v.UserNames != nil {
ok := object.Key("UserNames")
if err := awsAwsjson11_serializeDocumentUserNameListInput(v.UserNames, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateClusterInput(v *CreateClusterInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ACLName != nil {
ok := object.Key("ACLName")
ok.String(*v.ACLName)
}
if v.AutoMinorVersionUpgrade != nil {
ok := object.Key("AutoMinorVersionUpgrade")
ok.Boolean(*v.AutoMinorVersionUpgrade)
}
if v.ClusterName != nil {
ok := object.Key("ClusterName")
ok.String(*v.ClusterName)
}
if v.DataTiering != nil {
ok := object.Key("DataTiering")
ok.Boolean(*v.DataTiering)
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.EngineVersion != nil {
ok := object.Key("EngineVersion")
ok.String(*v.EngineVersion)
}
if v.KmsKeyId != nil {
ok := object.Key("KmsKeyId")
ok.String(*v.KmsKeyId)
}
if v.MaintenanceWindow != nil {
ok := object.Key("MaintenanceWindow")
ok.String(*v.MaintenanceWindow)
}
if v.NodeType != nil {
ok := object.Key("NodeType")
ok.String(*v.NodeType)
}
if v.NumReplicasPerShard != nil {
ok := object.Key("NumReplicasPerShard")
ok.Integer(*v.NumReplicasPerShard)
}
if v.NumShards != nil {
ok := object.Key("NumShards")
ok.Integer(*v.NumShards)
}
if v.ParameterGroupName != nil {
ok := object.Key("ParameterGroupName")
ok.String(*v.ParameterGroupName)
}
if v.Port != nil {
ok := object.Key("Port")
ok.Integer(*v.Port)
}
if v.SecurityGroupIds != nil {
ok := object.Key("SecurityGroupIds")
if err := awsAwsjson11_serializeDocumentSecurityGroupIdsList(v.SecurityGroupIds, ok); err != nil {
return err
}
}
if v.SnapshotArns != nil {
ok := object.Key("SnapshotArns")
if err := awsAwsjson11_serializeDocumentSnapshotArnsList(v.SnapshotArns, ok); err != nil {
return err
}
}
if v.SnapshotName != nil {
ok := object.Key("SnapshotName")
ok.String(*v.SnapshotName)
}
if v.SnapshotRetentionLimit != nil {
ok := object.Key("SnapshotRetentionLimit")
ok.Integer(*v.SnapshotRetentionLimit)
}
if v.SnapshotWindow != nil {
ok := object.Key("SnapshotWindow")
ok.String(*v.SnapshotWindow)
}
if v.SnsTopicArn != nil {
ok := object.Key("SnsTopicArn")
ok.String(*v.SnsTopicArn)
}
if v.SubnetGroupName != nil {
ok := object.Key("SubnetGroupName")
ok.String(*v.SubnetGroupName)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
if v.TLSEnabled != nil {
ok := object.Key("TLSEnabled")
ok.Boolean(*v.TLSEnabled)
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateParameterGroupInput(v *CreateParameterGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.Family != nil {
ok := object.Key("Family")
ok.String(*v.Family)
}
if v.ParameterGroupName != nil {
ok := object.Key("ParameterGroupName")
ok.String(*v.ParameterGroupName)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateSnapshotInput(v *CreateSnapshotInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClusterName != nil {
ok := object.Key("ClusterName")
ok.String(*v.ClusterName)
}
if v.KmsKeyId != nil {
ok := object.Key("KmsKeyId")
ok.String(*v.KmsKeyId)
}
if v.SnapshotName != nil {
ok := object.Key("SnapshotName")
ok.String(*v.SnapshotName)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateSubnetGroupInput(v *CreateSubnetGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.SubnetGroupName != nil {
ok := object.Key("SubnetGroupName")
ok.String(*v.SubnetGroupName)
}
if v.SubnetIds != nil {
ok := object.Key("SubnetIds")
if err := awsAwsjson11_serializeDocumentSubnetIdentifierList(v.SubnetIds, ok); err != nil {
return err
}
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentCreateUserInput(v *CreateUserInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccessString != nil {
ok := object.Key("AccessString")
ok.String(*v.AccessString)
}
if v.AuthenticationMode != nil {
ok := object.Key("AuthenticationMode")
if err := awsAwsjson11_serializeDocumentAuthenticationMode(v.AuthenticationMode, ok); err != nil {
return err
}
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
if v.UserName != nil {
ok := object.Key("UserName")
ok.String(*v.UserName)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteACLInput(v *DeleteACLInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ACLName != nil {
ok := object.Key("ACLName")
ok.String(*v.ACLName)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteClusterInput(v *DeleteClusterInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClusterName != nil {
ok := object.Key("ClusterName")
ok.String(*v.ClusterName)
}
if v.FinalSnapshotName != nil {
ok := object.Key("FinalSnapshotName")
ok.String(*v.FinalSnapshotName)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteParameterGroupInput(v *DeleteParameterGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ParameterGroupName != nil {
ok := object.Key("ParameterGroupName")
ok.String(*v.ParameterGroupName)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteSnapshotInput(v *DeleteSnapshotInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.SnapshotName != nil {
ok := object.Key("SnapshotName")
ok.String(*v.SnapshotName)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteSubnetGroupInput(v *DeleteSubnetGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.SubnetGroupName != nil {
ok := object.Key("SubnetGroupName")
ok.String(*v.SubnetGroupName)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteUserInput(v *DeleteUserInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.UserName != nil {
ok := object.Key("UserName")
ok.String(*v.UserName)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeACLsInput(v *DescribeACLsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ACLName != nil {
ok := object.Key("ACLName")
ok.String(*v.ACLName)
}
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
}
func awsAwsjson11_serializeOpDocumentDescribeClustersInput(v *DescribeClustersInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClusterName != nil {
ok := object.Key("ClusterName")
ok.String(*v.ClusterName)
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.ShowShardDetails != nil {
ok := object.Key("ShowShardDetails")
ok.Boolean(*v.ShowShardDetails)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeEngineVersionsInput(v *DescribeEngineVersionsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DefaultOnly {
ok := object.Key("DefaultOnly")
ok.Boolean(v.DefaultOnly)
}
if v.EngineVersion != nil {
ok := object.Key("EngineVersion")
ok.String(*v.EngineVersion)
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.ParameterGroupFamily != nil {
ok := object.Key("ParameterGroupFamily")
ok.String(*v.ParameterGroupFamily)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeEventsInput(v *DescribeEventsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Duration != nil {
ok := object.Key("Duration")
ok.Integer(*v.Duration)
}
if v.EndTime != nil {
ok := object.Key("EndTime")
ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.SourceName != nil {
ok := object.Key("SourceName")
ok.String(*v.SourceName)
}
if len(v.SourceType) > 0 {
ok := object.Key("SourceType")
ok.String(string(v.SourceType))
}
if v.StartTime != nil {
ok := object.Key("StartTime")
ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeParameterGroupsInput(v *DescribeParameterGroupsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.ParameterGroupName != nil {
ok := object.Key("ParameterGroupName")
ok.String(*v.ParameterGroupName)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeParametersInput(v *DescribeParametersInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.ParameterGroupName != nil {
ok := object.Key("ParameterGroupName")
ok.String(*v.ParameterGroupName)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeReservedNodesInput(v *DescribeReservedNodesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Duration != nil {
ok := object.Key("Duration")
ok.String(*v.Duration)
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.NodeType != nil {
ok := object.Key("NodeType")
ok.String(*v.NodeType)
}
if v.OfferingType != nil {
ok := object.Key("OfferingType")
ok.String(*v.OfferingType)
}
if v.ReservationId != nil {
ok := object.Key("ReservationId")
ok.String(*v.ReservationId)
}
if v.ReservedNodesOfferingId != nil {
ok := object.Key("ReservedNodesOfferingId")
ok.String(*v.ReservedNodesOfferingId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeReservedNodesOfferingsInput(v *DescribeReservedNodesOfferingsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Duration != nil {
ok := object.Key("Duration")
ok.String(*v.Duration)
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.NodeType != nil {
ok := object.Key("NodeType")
ok.String(*v.NodeType)
}
if v.OfferingType != nil {
ok := object.Key("OfferingType")
ok.String(*v.OfferingType)
}
if v.ReservedNodesOfferingId != nil {
ok := object.Key("ReservedNodesOfferingId")
ok.String(*v.ReservedNodesOfferingId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeServiceUpdatesInput(v *DescribeServiceUpdatesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClusterNames != nil {
ok := object.Key("ClusterNames")
if err := awsAwsjson11_serializeDocumentClusterNameList(v.ClusterNames, 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)
}
if v.ServiceUpdateName != nil {
ok := object.Key("ServiceUpdateName")
ok.String(*v.ServiceUpdateName)
}
if v.Status != nil {
ok := object.Key("Status")
if err := awsAwsjson11_serializeDocumentServiceUpdateStatusList(v.Status, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeSnapshotsInput(v *DescribeSnapshotsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClusterName != nil {
ok := object.Key("ClusterName")
ok.String(*v.ClusterName)
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.ShowDetail != nil {
ok := object.Key("ShowDetail")
ok.Boolean(*v.ShowDetail)
}
if v.SnapshotName != nil {
ok := object.Key("SnapshotName")
ok.String(*v.SnapshotName)
}
if v.Source != nil {
ok := object.Key("Source")
ok.String(*v.Source)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeSubnetGroupsInput(v *DescribeSubnetGroupsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.SubnetGroupName != nil {
ok := object.Key("SubnetGroupName")
ok.String(*v.SubnetGroupName)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDescribeUsersInput(v *DescribeUsersInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Filters != nil {
ok := object.Key("Filters")
if err := awsAwsjson11_serializeDocumentFilterList(v.Filters, 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)
}
if v.UserName != nil {
ok := object.Key("UserName")
ok.String(*v.UserName)
}
return nil
}
func awsAwsjson11_serializeOpDocumentFailoverShardInput(v *FailoverShardInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClusterName != nil {
ok := object.Key("ClusterName")
ok.String(*v.ClusterName)
}
if v.ShardName != nil {
ok := object.Key("ShardName")
ok.String(*v.ShardName)
}
return nil
}
func awsAwsjson11_serializeOpDocumentListAllowedNodeTypeUpdatesInput(v *ListAllowedNodeTypeUpdatesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClusterName != nil {
ok := object.Key("ClusterName")
ok.String(*v.ClusterName)
}
return nil
}
func awsAwsjson11_serializeOpDocumentListTagsInput(v *ListTagsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ResourceArn != nil {
ok := object.Key("ResourceArn")
ok.String(*v.ResourceArn)
}
return nil
}
func awsAwsjson11_serializeOpDocumentPurchaseReservedNodesOfferingInput(v *PurchaseReservedNodesOfferingInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.NodeCount != nil {
ok := object.Key("NodeCount")
ok.Integer(*v.NodeCount)
}
if v.ReservationId != nil {
ok := object.Key("ReservationId")
ok.String(*v.ReservationId)
}
if v.ReservedNodesOfferingId != nil {
ok := object.Key("ReservedNodesOfferingId")
ok.String(*v.ReservedNodesOfferingId)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentResetParameterGroupInput(v *ResetParameterGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AllParameters {
ok := object.Key("AllParameters")
ok.Boolean(v.AllParameters)
}
if v.ParameterGroupName != nil {
ok := object.Key("ParameterGroupName")
ok.String(*v.ParameterGroupName)
}
if v.ParameterNames != nil {
ok := object.Key("ParameterNames")
if err := awsAwsjson11_serializeDocumentParameterNameList(v.ParameterNames, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ResourceArn != nil {
ok := object.Key("ResourceArn")
ok.String(*v.ResourceArn)
}
if v.Tags != nil {
ok := object.Key("Tags")
if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ResourceArn != nil {
ok := object.Key("ResourceArn")
ok.String(*v.ResourceArn)
}
if v.TagKeys != nil {
ok := object.Key("TagKeys")
if err := awsAwsjson11_serializeDocumentKeyList(v.TagKeys, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateACLInput(v *UpdateACLInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ACLName != nil {
ok := object.Key("ACLName")
ok.String(*v.ACLName)
}
if v.UserNamesToAdd != nil {
ok := object.Key("UserNamesToAdd")
if err := awsAwsjson11_serializeDocumentUserNameListInput(v.UserNamesToAdd, ok); err != nil {
return err
}
}
if v.UserNamesToRemove != nil {
ok := object.Key("UserNamesToRemove")
if err := awsAwsjson11_serializeDocumentUserNameListInput(v.UserNamesToRemove, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateClusterInput(v *UpdateClusterInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ACLName != nil {
ok := object.Key("ACLName")
ok.String(*v.ACLName)
}
if v.ClusterName != nil {
ok := object.Key("ClusterName")
ok.String(*v.ClusterName)
}
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.EngineVersion != nil {
ok := object.Key("EngineVersion")
ok.String(*v.EngineVersion)
}
if v.MaintenanceWindow != nil {
ok := object.Key("MaintenanceWindow")
ok.String(*v.MaintenanceWindow)
}
if v.NodeType != nil {
ok := object.Key("NodeType")
ok.String(*v.NodeType)
}
if v.ParameterGroupName != nil {
ok := object.Key("ParameterGroupName")
ok.String(*v.ParameterGroupName)
}
if v.ReplicaConfiguration != nil {
ok := object.Key("ReplicaConfiguration")
if err := awsAwsjson11_serializeDocumentReplicaConfigurationRequest(v.ReplicaConfiguration, ok); err != nil {
return err
}
}
if v.SecurityGroupIds != nil {
ok := object.Key("SecurityGroupIds")
if err := awsAwsjson11_serializeDocumentSecurityGroupIdsList(v.SecurityGroupIds, ok); err != nil {
return err
}
}
if v.ShardConfiguration != nil {
ok := object.Key("ShardConfiguration")
if err := awsAwsjson11_serializeDocumentShardConfigurationRequest(v.ShardConfiguration, ok); err != nil {
return err
}
}
if v.SnapshotRetentionLimit != nil {
ok := object.Key("SnapshotRetentionLimit")
ok.Integer(*v.SnapshotRetentionLimit)
}
if v.SnapshotWindow != nil {
ok := object.Key("SnapshotWindow")
ok.String(*v.SnapshotWindow)
}
if v.SnsTopicArn != nil {
ok := object.Key("SnsTopicArn")
ok.String(*v.SnsTopicArn)
}
if v.SnsTopicStatus != nil {
ok := object.Key("SnsTopicStatus")
ok.String(*v.SnsTopicStatus)
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateParameterGroupInput(v *UpdateParameterGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ParameterGroupName != nil {
ok := object.Key("ParameterGroupName")
ok.String(*v.ParameterGroupName)
}
if v.ParameterNameValues != nil {
ok := object.Key("ParameterNameValues")
if err := awsAwsjson11_serializeDocumentParameterNameValueList(v.ParameterNameValues, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateSubnetGroupInput(v *UpdateSubnetGroupInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.SubnetGroupName != nil {
ok := object.Key("SubnetGroupName")
ok.String(*v.SubnetGroupName)
}
if v.SubnetIds != nil {
ok := object.Key("SubnetIds")
if err := awsAwsjson11_serializeDocumentSubnetIdentifierList(v.SubnetIds, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentUpdateUserInput(v *UpdateUserInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccessString != nil {
ok := object.Key("AccessString")
ok.String(*v.AccessString)
}
if v.AuthenticationMode != nil {
ok := object.Key("AuthenticationMode")
if err := awsAwsjson11_serializeDocumentAuthenticationMode(v.AuthenticationMode, ok); err != nil {
return err
}
}
if v.UserName != nil {
ok := object.Key("UserName")
ok.String(*v.UserName)
}
return nil
}
| 3,443 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package memorydb
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/memorydb/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpBatchUpdateCluster struct {
}
func (*validateOpBatchUpdateCluster) ID() string {
return "OperationInputValidation"
}
func (m *validateOpBatchUpdateCluster) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*BatchUpdateClusterInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpBatchUpdateClusterInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCopySnapshot struct {
}
func (*validateOpCopySnapshot) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCopySnapshot) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CopySnapshotInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCopySnapshotInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateACL struct {
}
func (*validateOpCreateACL) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateACL) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateACLInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateACLInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateCluster struct {
}
func (*validateOpCreateCluster) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateCluster) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateClusterInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateClusterInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateParameterGroup struct {
}
func (*validateOpCreateParameterGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateParameterGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateParameterGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateParameterGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateSnapshot struct {
}
func (*validateOpCreateSnapshot) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateSnapshot) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateSnapshotInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateSnapshotInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateSubnetGroup struct {
}
func (*validateOpCreateSubnetGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateSubnetGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateSubnetGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateSubnetGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateUser struct {
}
func (*validateOpCreateUser) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateUserInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateUserInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteACL struct {
}
func (*validateOpDeleteACL) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteACL) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteACLInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteACLInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteCluster struct {
}
func (*validateOpDeleteCluster) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteCluster) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteClusterInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteClusterInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteParameterGroup struct {
}
func (*validateOpDeleteParameterGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteParameterGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteParameterGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteParameterGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteSnapshot struct {
}
func (*validateOpDeleteSnapshot) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteSnapshot) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteSnapshotInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteSnapshotInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteSubnetGroup struct {
}
func (*validateOpDeleteSubnetGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteSubnetGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteSubnetGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteSubnetGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteUser struct {
}
func (*validateOpDeleteUser) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteUserInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteUserInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeParameters struct {
}
func (*validateOpDescribeParameters) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeParameters) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeParametersInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeParametersInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeUsers struct {
}
func (*validateOpDescribeUsers) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeUsers) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeUsersInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeUsersInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpFailoverShard struct {
}
func (*validateOpFailoverShard) ID() string {
return "OperationInputValidation"
}
func (m *validateOpFailoverShard) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*FailoverShardInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpFailoverShardInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListAllowedNodeTypeUpdates struct {
}
func (*validateOpListAllowedNodeTypeUpdates) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListAllowedNodeTypeUpdates) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListAllowedNodeTypeUpdatesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListAllowedNodeTypeUpdatesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListTags struct {
}
func (*validateOpListTags) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListTags) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListTagsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListTagsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpPurchaseReservedNodesOffering struct {
}
func (*validateOpPurchaseReservedNodesOffering) ID() string {
return "OperationInputValidation"
}
func (m *validateOpPurchaseReservedNodesOffering) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*PurchaseReservedNodesOfferingInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpPurchaseReservedNodesOfferingInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpResetParameterGroup struct {
}
func (*validateOpResetParameterGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpResetParameterGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ResetParameterGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpResetParameterGroupInput(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 validateOpUpdateACL struct {
}
func (*validateOpUpdateACL) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateACL) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateACLInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateACLInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateCluster struct {
}
func (*validateOpUpdateCluster) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateCluster) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateClusterInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateClusterInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateParameterGroup struct {
}
func (*validateOpUpdateParameterGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateParameterGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateParameterGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateParameterGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateSubnetGroup struct {
}
func (*validateOpUpdateSubnetGroup) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateSubnetGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateSubnetGroupInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateSubnetGroupInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateUser struct {
}
func (*validateOpUpdateUser) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateUserInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateUserInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpBatchUpdateClusterValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpBatchUpdateCluster{}, middleware.After)
}
func addOpCopySnapshotValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCopySnapshot{}, middleware.After)
}
func addOpCreateACLValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateACL{}, middleware.After)
}
func addOpCreateClusterValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateCluster{}, middleware.After)
}
func addOpCreateParameterGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateParameterGroup{}, middleware.After)
}
func addOpCreateSnapshotValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateSnapshot{}, middleware.After)
}
func addOpCreateSubnetGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateSubnetGroup{}, middleware.After)
}
func addOpCreateUserValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateUser{}, middleware.After)
}
func addOpDeleteACLValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteACL{}, middleware.After)
}
func addOpDeleteClusterValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteCluster{}, middleware.After)
}
func addOpDeleteParameterGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteParameterGroup{}, middleware.After)
}
func addOpDeleteSnapshotValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteSnapshot{}, middleware.After)
}
func addOpDeleteSubnetGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteSubnetGroup{}, middleware.After)
}
func addOpDeleteUserValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteUser{}, middleware.After)
}
func addOpDescribeParametersValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeParameters{}, middleware.After)
}
func addOpDescribeUsersValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeUsers{}, middleware.After)
}
func addOpFailoverShardValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpFailoverShard{}, middleware.After)
}
func addOpListAllowedNodeTypeUpdatesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListAllowedNodeTypeUpdates{}, middleware.After)
}
func addOpListTagsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListTags{}, middleware.After)
}
func addOpPurchaseReservedNodesOfferingValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpPurchaseReservedNodesOffering{}, middleware.After)
}
func addOpResetParameterGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpResetParameterGroup{}, 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 addOpUpdateACLValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateACL{}, middleware.After)
}
func addOpUpdateClusterValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateCluster{}, middleware.After)
}
func addOpUpdateParameterGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateParameterGroup{}, middleware.After)
}
func addOpUpdateSubnetGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateSubnetGroup{}, middleware.After)
}
func addOpUpdateUserValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateUser{}, middleware.After)
}
func validateFilter(v *types.Filter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Filter"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.Values == nil {
invalidParams.Add(smithy.NewErrParamRequired("Values"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateFilterList(v []types.Filter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "FilterList"}
for i := range v {
if err := validateFilter(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpBatchUpdateClusterInput(v *BatchUpdateClusterInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchUpdateClusterInput"}
if v.ClusterNames == nil {
invalidParams.Add(smithy.NewErrParamRequired("ClusterNames"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCopySnapshotInput(v *CopySnapshotInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CopySnapshotInput"}
if v.SourceSnapshotName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SourceSnapshotName"))
}
if v.TargetSnapshotName == nil {
invalidParams.Add(smithy.NewErrParamRequired("TargetSnapshotName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateACLInput(v *CreateACLInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateACLInput"}
if v.ACLName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ACLName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateClusterInput(v *CreateClusterInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateClusterInput"}
if v.ClusterName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ClusterName"))
}
if v.NodeType == nil {
invalidParams.Add(smithy.NewErrParamRequired("NodeType"))
}
if v.ACLName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ACLName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateParameterGroupInput(v *CreateParameterGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateParameterGroupInput"}
if v.ParameterGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupName"))
}
if v.Family == nil {
invalidParams.Add(smithy.NewErrParamRequired("Family"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateSnapshotInput(v *CreateSnapshotInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateSnapshotInput"}
if v.ClusterName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ClusterName"))
}
if v.SnapshotName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SnapshotName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateSubnetGroupInput(v *CreateSubnetGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateSubnetGroupInput"}
if v.SubnetGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SubnetGroupName"))
}
if v.SubnetIds == nil {
invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateUserInput(v *CreateUserInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateUserInput"}
if v.UserName == nil {
invalidParams.Add(smithy.NewErrParamRequired("UserName"))
}
if v.AuthenticationMode == nil {
invalidParams.Add(smithy.NewErrParamRequired("AuthenticationMode"))
}
if v.AccessString == nil {
invalidParams.Add(smithy.NewErrParamRequired("AccessString"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteACLInput(v *DeleteACLInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteACLInput"}
if v.ACLName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ACLName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteClusterInput(v *DeleteClusterInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteClusterInput"}
if v.ClusterName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ClusterName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteParameterGroupInput(v *DeleteParameterGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteParameterGroupInput"}
if v.ParameterGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteSnapshotInput(v *DeleteSnapshotInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteSnapshotInput"}
if v.SnapshotName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SnapshotName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteSubnetGroupInput(v *DeleteSubnetGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteSubnetGroupInput"}
if v.SubnetGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SubnetGroupName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteUserInput(v *DeleteUserInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteUserInput"}
if v.UserName == nil {
invalidParams.Add(smithy.NewErrParamRequired("UserName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeParametersInput(v *DescribeParametersInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeParametersInput"}
if v.ParameterGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeUsersInput(v *DescribeUsersInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeUsersInput"}
if v.Filters != nil {
if err := validateFilterList(v.Filters); err != nil {
invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpFailoverShardInput(v *FailoverShardInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "FailoverShardInput"}
if v.ClusterName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ClusterName"))
}
if v.ShardName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ShardName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListAllowedNodeTypeUpdatesInput(v *ListAllowedNodeTypeUpdatesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListAllowedNodeTypeUpdatesInput"}
if v.ClusterName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ClusterName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListTagsInput(v *ListTagsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListTagsInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpPurchaseReservedNodesOfferingInput(v *PurchaseReservedNodesOfferingInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PurchaseReservedNodesOfferingInput"}
if v.ReservedNodesOfferingId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ReservedNodesOfferingId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpResetParameterGroupInput(v *ResetParameterGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ResetParameterGroupInput"}
if v.ParameterGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupName"))
}
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 validateOpUpdateACLInput(v *UpdateACLInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateACLInput"}
if v.ACLName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ACLName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateClusterInput(v *UpdateClusterInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateClusterInput"}
if v.ClusterName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ClusterName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateParameterGroupInput(v *UpdateParameterGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateParameterGroupInput"}
if v.ParameterGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupName"))
}
if v.ParameterNameValues == nil {
invalidParams.Add(smithy.NewErrParamRequired("ParameterNameValues"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateSubnetGroupInput(v *UpdateSubnetGroupInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateSubnetGroupInput"}
if v.SubnetGroupName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SubnetGroupName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateUserInput(v *UpdateUserInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateUserInput"}
if v.UserName == nil {
invalidParams.Add(smithy.NewErrParamRequired("UserName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 1,177 |
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 MemoryDB 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: "memory-db.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "memory-db-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "memory-db-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "memory-db.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
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: "eu-central-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-north-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-3",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "fips",
}: endpoints.Endpoint{
Hostname: "memory-db-fips.us-west-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-west-1",
},
},
endpoints.EndpointKey{
Region: "sa-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-east-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-west-2",
}: endpoints.Endpoint{},
},
},
{
ID: "aws-cn",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "memory-db.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "memory-db-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "memory-db-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "memory-db.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsCn,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "cn-north-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "cn-northwest-1",
}: endpoints.Endpoint{},
},
},
{
ID: "aws-iso",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "memory-db-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "memory-db.{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: "memory-db-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "memory-db.{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: "memory-db-fips.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "memory-db.{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: "memory-db-fips.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "memory-db.{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: "memory-db.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "memory-db-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "memory-db-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "memory-db.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: true,
},
}
| 369 |
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 AuthenticationType string
// Enum values for AuthenticationType
const (
AuthenticationTypePassword AuthenticationType = "password"
AuthenticationTypeNoPassword AuthenticationType = "no-password"
AuthenticationTypeIam AuthenticationType = "iam"
)
// Values returns all known values for AuthenticationType. 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 (AuthenticationType) Values() []AuthenticationType {
return []AuthenticationType{
"password",
"no-password",
"iam",
}
}
type AZStatus string
// Enum values for AZStatus
const (
AZStatusSingleAZ AZStatus = "singleaz"
AZStatusMultiAZ AZStatus = "multiaz"
)
// Values returns all known values for AZStatus. 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 (AZStatus) Values() []AZStatus {
return []AZStatus{
"singleaz",
"multiaz",
}
}
type DataTieringStatus string
// Enum values for DataTieringStatus
const (
DataTieringStatusTrue DataTieringStatus = "true"
DataTieringStatusFalse DataTieringStatus = "false"
)
// Values returns all known values for DataTieringStatus. 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 (DataTieringStatus) Values() []DataTieringStatus {
return []DataTieringStatus{
"true",
"false",
}
}
type InputAuthenticationType string
// Enum values for InputAuthenticationType
const (
InputAuthenticationTypePassword InputAuthenticationType = "password"
InputAuthenticationTypeIam InputAuthenticationType = "iam"
)
// Values returns all known values for InputAuthenticationType. 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 (InputAuthenticationType) Values() []InputAuthenticationType {
return []InputAuthenticationType{
"password",
"iam",
}
}
type ServiceUpdateStatus string
// Enum values for ServiceUpdateStatus
const (
ServiceUpdateStatusNotApplied ServiceUpdateStatus = "available"
ServiceUpdateStatusInProgress ServiceUpdateStatus = "in-progress"
ServiceUpdateStatusComplete ServiceUpdateStatus = "complete"
ServiceUpdateStatusScheduled ServiceUpdateStatus = "scheduled"
)
// Values returns all known values for ServiceUpdateStatus. 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 (ServiceUpdateStatus) Values() []ServiceUpdateStatus {
return []ServiceUpdateStatus{
"available",
"in-progress",
"complete",
"scheduled",
}
}
type ServiceUpdateType string
// Enum values for ServiceUpdateType
const (
ServiceUpdateTypeSecurityUpdate ServiceUpdateType = "security-update"
)
// Values returns all known values for ServiceUpdateType. 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 (ServiceUpdateType) Values() []ServiceUpdateType {
return []ServiceUpdateType{
"security-update",
}
}
type SourceType string
// Enum values for SourceType
const (
SourceTypeNode SourceType = "node"
SourceTypeParameterGroup SourceType = "parameter-group"
SourceTypeSubnetGroup SourceType = "subnet-group"
SourceTypeCluster SourceType = "cluster"
SourceTypeUser SourceType = "user"
SourceTypeAcl SourceType = "acl"
)
// Values returns all known values for SourceType. 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 (SourceType) Values() []SourceType {
return []SourceType{
"node",
"parameter-group",
"subnet-group",
"cluster",
"user",
"acl",
}
}
| 142 |
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"
)
type ACLAlreadyExistsFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ACLAlreadyExistsFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ACLAlreadyExistsFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ACLAlreadyExistsFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ACLAlreadyExistsFault"
}
return *e.ErrorCodeOverride
}
func (e *ACLAlreadyExistsFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type ACLNotFoundFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ACLNotFoundFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ACLNotFoundFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ACLNotFoundFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ACLNotFoundFault"
}
return *e.ErrorCodeOverride
}
func (e *ACLNotFoundFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type ACLQuotaExceededFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ACLQuotaExceededFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ACLQuotaExceededFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ACLQuotaExceededFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ACLQuotaExceededFault"
}
return *e.ErrorCodeOverride
}
func (e *ACLQuotaExceededFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type APICallRateForCustomerExceededFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *APICallRateForCustomerExceededFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *APICallRateForCustomerExceededFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *APICallRateForCustomerExceededFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "APICallRateForCustomerExceededFault"
}
return *e.ErrorCodeOverride
}
func (e *APICallRateForCustomerExceededFault) ErrorFault() smithy.ErrorFault {
return smithy.FaultClient
}
type ClusterAlreadyExistsFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ClusterAlreadyExistsFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ClusterAlreadyExistsFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ClusterAlreadyExistsFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ClusterAlreadyExistsFault"
}
return *e.ErrorCodeOverride
}
func (e *ClusterAlreadyExistsFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type ClusterNotFoundFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ClusterNotFoundFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ClusterNotFoundFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ClusterNotFoundFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ClusterNotFoundFault"
}
return *e.ErrorCodeOverride
}
func (e *ClusterNotFoundFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type ClusterQuotaForCustomerExceededFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ClusterQuotaForCustomerExceededFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ClusterQuotaForCustomerExceededFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ClusterQuotaForCustomerExceededFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ClusterQuotaForCustomerExceededFault"
}
return *e.ErrorCodeOverride
}
func (e *ClusterQuotaForCustomerExceededFault) ErrorFault() smithy.ErrorFault {
return smithy.FaultClient
}
type DefaultUserRequired struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *DefaultUserRequired) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *DefaultUserRequired) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *DefaultUserRequired) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "DefaultUserRequired"
}
return *e.ErrorCodeOverride
}
func (e *DefaultUserRequired) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type DuplicateUserNameFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *DuplicateUserNameFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *DuplicateUserNameFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *DuplicateUserNameFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "DuplicateUserNameFault"
}
return *e.ErrorCodeOverride
}
func (e *DuplicateUserNameFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type InsufficientClusterCapacityFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InsufficientClusterCapacityFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InsufficientClusterCapacityFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InsufficientClusterCapacityFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InsufficientClusterCapacityFault"
}
return *e.ErrorCodeOverride
}
func (e *InsufficientClusterCapacityFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type InvalidACLStateFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidACLStateFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidACLStateFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidACLStateFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidACLStateFault"
}
return *e.ErrorCodeOverride
}
func (e *InvalidACLStateFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type InvalidARNFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidARNFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidARNFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidARNFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidARNFault"
}
return *e.ErrorCodeOverride
}
func (e *InvalidARNFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type InvalidClusterStateFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidClusterStateFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidClusterStateFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidClusterStateFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidClusterStateFault"
}
return *e.ErrorCodeOverride
}
func (e *InvalidClusterStateFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type InvalidCredentialsException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidCredentialsException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidCredentialsException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidCredentialsException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidCredentialsException"
}
return *e.ErrorCodeOverride
}
func (e *InvalidCredentialsException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type InvalidKMSKeyFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidKMSKeyFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidKMSKeyFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidKMSKeyFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidKMSKeyFault"
}
return *e.ErrorCodeOverride
}
func (e *InvalidKMSKeyFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type InvalidNodeStateFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidNodeStateFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidNodeStateFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidNodeStateFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidNodeStateFault"
}
return *e.ErrorCodeOverride
}
func (e *InvalidNodeStateFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type InvalidParameterCombinationException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidParameterCombinationException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidParameterCombinationException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidParameterCombinationException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidParameterCombinationException"
}
return *e.ErrorCodeOverride
}
func (e *InvalidParameterCombinationException) ErrorFault() smithy.ErrorFault {
return smithy.FaultClient
}
type InvalidParameterGroupStateFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidParameterGroupStateFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidParameterGroupStateFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidParameterGroupStateFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidParameterGroupStateFault"
}
return *e.ErrorCodeOverride
}
func (e *InvalidParameterGroupStateFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type InvalidParameterValueException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidParameterValueException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidParameterValueException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidParameterValueException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidParameterValueException"
}
return *e.ErrorCodeOverride
}
func (e *InvalidParameterValueException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type InvalidSnapshotStateFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidSnapshotStateFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidSnapshotStateFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidSnapshotStateFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidSnapshotStateFault"
}
return *e.ErrorCodeOverride
}
func (e *InvalidSnapshotStateFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type InvalidSubnet struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidSubnet) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidSubnet) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidSubnet) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidSubnet"
}
return *e.ErrorCodeOverride
}
func (e *InvalidSubnet) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type InvalidUserStateFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidUserStateFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidUserStateFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidUserStateFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidUserStateFault"
}
return *e.ErrorCodeOverride
}
func (e *InvalidUserStateFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type InvalidVPCNetworkStateFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidVPCNetworkStateFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidVPCNetworkStateFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidVPCNetworkStateFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidVPCNetworkStateFault"
}
return *e.ErrorCodeOverride
}
func (e *InvalidVPCNetworkStateFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type NodeQuotaForClusterExceededFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *NodeQuotaForClusterExceededFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *NodeQuotaForClusterExceededFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *NodeQuotaForClusterExceededFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "NodeQuotaForClusterExceededFault"
}
return *e.ErrorCodeOverride
}
func (e *NodeQuotaForClusterExceededFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type NodeQuotaForCustomerExceededFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *NodeQuotaForCustomerExceededFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *NodeQuotaForCustomerExceededFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *NodeQuotaForCustomerExceededFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "NodeQuotaForCustomerExceededFault"
}
return *e.ErrorCodeOverride
}
func (e *NodeQuotaForCustomerExceededFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type NoOperationFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *NoOperationFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *NoOperationFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *NoOperationFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "NoOperationFault"
}
return *e.ErrorCodeOverride
}
func (e *NoOperationFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type ParameterGroupAlreadyExistsFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ParameterGroupAlreadyExistsFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ParameterGroupAlreadyExistsFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ParameterGroupAlreadyExistsFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ParameterGroupAlreadyExistsFault"
}
return *e.ErrorCodeOverride
}
func (e *ParameterGroupAlreadyExistsFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type ParameterGroupNotFoundFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ParameterGroupNotFoundFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ParameterGroupNotFoundFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ParameterGroupNotFoundFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ParameterGroupNotFoundFault"
}
return *e.ErrorCodeOverride
}
func (e *ParameterGroupNotFoundFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type ParameterGroupQuotaExceededFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ParameterGroupQuotaExceededFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ParameterGroupQuotaExceededFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ParameterGroupQuotaExceededFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ParameterGroupQuotaExceededFault"
}
return *e.ErrorCodeOverride
}
func (e *ParameterGroupQuotaExceededFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// You already have a reservation with the given identifier.
type ReservedNodeAlreadyExistsFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ReservedNodeAlreadyExistsFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ReservedNodeAlreadyExistsFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ReservedNodeAlreadyExistsFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ReservedNodeAlreadyExistsFault"
}
return *e.ErrorCodeOverride
}
func (e *ReservedNodeAlreadyExistsFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The requested node does not exist.
type ReservedNodeNotFoundFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ReservedNodeNotFoundFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ReservedNodeNotFoundFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ReservedNodeNotFoundFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ReservedNodeNotFoundFault"
}
return *e.ErrorCodeOverride
}
func (e *ReservedNodeNotFoundFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The request cannot be processed because it would exceed the user's node quota.
type ReservedNodeQuotaExceededFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ReservedNodeQuotaExceededFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ReservedNodeQuotaExceededFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ReservedNodeQuotaExceededFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ReservedNodeQuotaExceededFault"
}
return *e.ErrorCodeOverride
}
func (e *ReservedNodeQuotaExceededFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The requested node offering does not exist.
type ReservedNodesOfferingNotFoundFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ReservedNodesOfferingNotFoundFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ReservedNodesOfferingNotFoundFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ReservedNodesOfferingNotFoundFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ReservedNodesOfferingNotFoundFault"
}
return *e.ErrorCodeOverride
}
func (e *ReservedNodesOfferingNotFoundFault) ErrorFault() smithy.ErrorFault {
return smithy.FaultClient
}
type ServiceLinkedRoleNotFoundFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ServiceLinkedRoleNotFoundFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ServiceLinkedRoleNotFoundFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ServiceLinkedRoleNotFoundFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ServiceLinkedRoleNotFoundFault"
}
return *e.ErrorCodeOverride
}
func (e *ServiceLinkedRoleNotFoundFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type ServiceUpdateNotFoundFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ServiceUpdateNotFoundFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ServiceUpdateNotFoundFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ServiceUpdateNotFoundFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ServiceUpdateNotFoundFault"
}
return *e.ErrorCodeOverride
}
func (e *ServiceUpdateNotFoundFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type ShardNotFoundFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ShardNotFoundFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ShardNotFoundFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ShardNotFoundFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ShardNotFoundFault"
}
return *e.ErrorCodeOverride
}
func (e *ShardNotFoundFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type ShardsPerClusterQuotaExceededFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ShardsPerClusterQuotaExceededFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ShardsPerClusterQuotaExceededFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ShardsPerClusterQuotaExceededFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ShardsPerClusterQuotaExceededFault"
}
return *e.ErrorCodeOverride
}
func (e *ShardsPerClusterQuotaExceededFault) ErrorFault() smithy.ErrorFault {
return smithy.FaultClient
}
type SnapshotAlreadyExistsFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *SnapshotAlreadyExistsFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *SnapshotAlreadyExistsFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *SnapshotAlreadyExistsFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "SnapshotAlreadyExistsFault"
}
return *e.ErrorCodeOverride
}
func (e *SnapshotAlreadyExistsFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type SnapshotNotFoundFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *SnapshotNotFoundFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *SnapshotNotFoundFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *SnapshotNotFoundFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "SnapshotNotFoundFault"
}
return *e.ErrorCodeOverride
}
func (e *SnapshotNotFoundFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type SnapshotQuotaExceededFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *SnapshotQuotaExceededFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *SnapshotQuotaExceededFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *SnapshotQuotaExceededFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "SnapshotQuotaExceededFault"
}
return *e.ErrorCodeOverride
}
func (e *SnapshotQuotaExceededFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type SubnetGroupAlreadyExistsFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *SubnetGroupAlreadyExistsFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *SubnetGroupAlreadyExistsFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *SubnetGroupAlreadyExistsFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "SubnetGroupAlreadyExistsFault"
}
return *e.ErrorCodeOverride
}
func (e *SubnetGroupAlreadyExistsFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type SubnetGroupInUseFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *SubnetGroupInUseFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *SubnetGroupInUseFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *SubnetGroupInUseFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "SubnetGroupInUseFault"
}
return *e.ErrorCodeOverride
}
func (e *SubnetGroupInUseFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type SubnetGroupNotFoundFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *SubnetGroupNotFoundFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *SubnetGroupNotFoundFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *SubnetGroupNotFoundFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "SubnetGroupNotFoundFault"
}
return *e.ErrorCodeOverride
}
func (e *SubnetGroupNotFoundFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type SubnetGroupQuotaExceededFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *SubnetGroupQuotaExceededFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *SubnetGroupQuotaExceededFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *SubnetGroupQuotaExceededFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "SubnetGroupQuotaExceededFault"
}
return *e.ErrorCodeOverride
}
func (e *SubnetGroupQuotaExceededFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type SubnetInUse struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *SubnetInUse) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *SubnetInUse) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *SubnetInUse) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "SubnetInUse"
}
return *e.ErrorCodeOverride
}
func (e *SubnetInUse) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type SubnetNotAllowedFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *SubnetNotAllowedFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *SubnetNotAllowedFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *SubnetNotAllowedFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "SubnetNotAllowedFault"
}
return *e.ErrorCodeOverride
}
func (e *SubnetNotAllowedFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type SubnetQuotaExceededFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *SubnetQuotaExceededFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *SubnetQuotaExceededFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *SubnetQuotaExceededFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "SubnetQuotaExceededFault"
}
return *e.ErrorCodeOverride
}
func (e *SubnetQuotaExceededFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type TagNotFoundFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *TagNotFoundFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *TagNotFoundFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *TagNotFoundFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "TagNotFoundFault"
}
return *e.ErrorCodeOverride
}
func (e *TagNotFoundFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type TagQuotaPerResourceExceeded struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *TagQuotaPerResourceExceeded) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *TagQuotaPerResourceExceeded) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *TagQuotaPerResourceExceeded) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "TagQuotaPerResourceExceeded"
}
return *e.ErrorCodeOverride
}
func (e *TagQuotaPerResourceExceeded) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type TestFailoverNotAvailableFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *TestFailoverNotAvailableFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *TestFailoverNotAvailableFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *TestFailoverNotAvailableFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "TestFailoverNotAvailableFault"
}
return *e.ErrorCodeOverride
}
func (e *TestFailoverNotAvailableFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type UserAlreadyExistsFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *UserAlreadyExistsFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *UserAlreadyExistsFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *UserAlreadyExistsFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "UserAlreadyExistsFault"
}
return *e.ErrorCodeOverride
}
func (e *UserAlreadyExistsFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type UserNotFoundFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *UserNotFoundFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *UserNotFoundFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *UserNotFoundFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "UserNotFoundFault"
}
return *e.ErrorCodeOverride
}
func (e *UserNotFoundFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
type UserQuotaExceededFault struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *UserQuotaExceededFault) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *UserQuotaExceededFault) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *UserQuotaExceededFault) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "UserQuotaExceededFault"
}
return *e.ErrorCodeOverride
}
func (e *UserQuotaExceededFault) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
| 1,348 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
smithydocument "github.com/aws/smithy-go/document"
"time"
)
// An Access Control List. You can authenticate users with Access Contol Lists.
// ACLs enable you to control cluster access by grouping users. These Access
// control lists are designed as a way to organize access to clusters.
type ACL struct {
// The Amazon Resource Name (ARN) of the ACL
ARN *string
// A list of clusters associated with the ACL.
Clusters []string
// The minimum engine version supported for the ACL
MinimumEngineVersion *string
// The name of the Access Control List
Name *string
// A list of updates being applied to the ACL.
PendingChanges *ACLPendingChanges
// Indicates ACL status. Can be "creating", "active", "modifying", "deleting".
Status *string
// The list of user names that belong to the ACL.
UserNames []string
noSmithyDocumentSerde
}
// Returns the updates being applied to the ACL.
type ACLPendingChanges struct {
// A list of users being added to the ACL
UserNamesToAdd []string
// A list of user names being removed from the ACL
UserNamesToRemove []string
noSmithyDocumentSerde
}
// The status of the ACL update
type ACLsUpdateStatus struct {
// A list of ACLs pending to be applied.
ACLToApply *string
noSmithyDocumentSerde
}
// Denotes the user's authentication properties, such as whether it requires a
// password to authenticate. Used in output responses.
type Authentication struct {
// The number of passwords belonging to the user. The maximum is two.
PasswordCount *int32
// Indicates whether the user requires a password to authenticate.
Type AuthenticationType
noSmithyDocumentSerde
}
// Denotes the user's authentication properties, such as whether it requires a
// password to authenticate. Used in output responses.
type AuthenticationMode struct {
// The password(s) used for authentication
Passwords []string
// Indicates whether the user requires a password to authenticate. All
// newly-created users require a password.
Type InputAuthenticationType
noSmithyDocumentSerde
}
// Indicates if the cluster has a Multi-AZ configuration (multiaz) or not
// (singleaz).
type AvailabilityZone struct {
// The name of the Availability Zone.
Name *string
noSmithyDocumentSerde
}
// Contains all of the attributes of a specific cluster.
type Cluster struct {
// The name of the Access Control List associated with this cluster.
ACLName *string
// The Amazon Resource Name (ARN) of the cluster.
ARN *string
// When set to true, the cluster will automatically receive minor engine version
// upgrades after launch.
AutoMinorVersionUpgrade *bool
// Indicates if the cluster has a Multi-AZ configuration (multiaz) or not
// (singleaz).
AvailabilityMode AZStatus
// The cluster's configuration endpoint
ClusterEndpoint *Endpoint
// Enables data tiering. Data tiering is only supported for clusters using the
// r6gd node type. This parameter must be set when using r6gd nodes. For more
// information, see Data tiering (https://docs.aws.amazon.com/memorydb/latest/devguide/data-tiering.html)
// .
DataTiering DataTieringStatus
// A description of the cluster
Description *string
// The Redis engine patch version used by the cluster
EnginePatchVersion *string
// The Redis engine version used by the cluster
EngineVersion *string
// The ID of the KMS key used to encrypt the cluster
KmsKeyId *string
// Specifies the weekly time range during which maintenance on the cluster is
// performed. It is specified as a range in the format ddd:hh24:mi-ddd:hh24:mi (24H
// Clock UTC). The minimum maintenance window is a 60 minute period.
MaintenanceWindow *string
// The user-supplied name of the cluster. This identifier is a unique key that
// identifies a cluster.
Name *string
// The cluster's node type
NodeType *string
// The number of shards in the cluster
NumberOfShards *int32
// The name of the parameter group used by the cluster
ParameterGroupName *string
// The status of the parameter group used by the cluster, for example 'active' or
// 'applying'.
ParameterGroupStatus *string
// A group of settings that are currently being applied.
PendingUpdates *ClusterPendingUpdates
// A list of security groups used by the cluster
SecurityGroups []SecurityGroupMembership
// A list of shards that are members of the cluster.
Shards []Shard
// The number of days for which MemoryDB retains automatic snapshots before
// deleting them. For example, if you set SnapshotRetentionLimit to 5, a snapshot
// that was taken today is retained for 5 days before being deleted.
SnapshotRetentionLimit *int32
// The daily time range (in UTC) during which MemoryDB begins taking a daily
// snapshot of your shard. Example: 05:00-09:00 If you do not specify this
// parameter, MemoryDB automatically chooses an appropriate time range.
SnapshotWindow *string
// The Amazon Resource Name (ARN) of the SNS notification topic
SnsTopicArn *string
// The SNS topic must be in Active status to receive notifications
SnsTopicStatus *string
// The status of the cluster. For example, Available, Updating, Creating.
Status *string
// The name of the subnet group used by the cluster
SubnetGroupName *string
// A flag to indicate if In-transit encryption is enabled
TLSEnabled *bool
noSmithyDocumentSerde
}
// A list of cluster configuration options.
type ClusterConfiguration struct {
// The description of the cluster configuration
Description *string
// The Redis engine version used by the cluster
EngineVersion *string
// The specified maintenance window for the cluster
MaintenanceWindow *string
// The name of the cluster
Name *string
// The node type used for the cluster
NodeType *string
// The number of shards in the cluster
NumShards *int32
// The name of parameter group used by the cluster
ParameterGroupName *string
// The port used by the cluster
Port *int32
// The list of shards in the cluster
Shards []ShardDetail
// The snapshot retention limit set by the cluster
SnapshotRetentionLimit *int32
// The snapshot window set by the cluster
SnapshotWindow *string
// The name of the subnet group used by the cluster
SubnetGroupName *string
// The Amazon Resource Name (ARN) of the SNS notification topic for the cluster
TopicArn *string
// The ID of the VPC the cluster belongs to
VpcId *string
noSmithyDocumentSerde
}
// A list of updates being applied to the cluster
type ClusterPendingUpdates struct {
// A list of ACLs associated with the cluster that are being updated
ACLs *ACLsUpdateStatus
// The status of an online resharding operation.
Resharding *ReshardingStatus
// A list of service updates being applied to the cluster
ServiceUpdates []PendingModifiedServiceUpdate
noSmithyDocumentSerde
}
// Represents the information required for client programs to connect to the
// cluster and its nodes.
type Endpoint struct {
// The DNS hostname of the node.
Address *string
// The port number that the engine is listening on.
Port int32
noSmithyDocumentSerde
}
// Provides details of the Redis engine version
type EngineVersionInfo struct {
// The patched engine version
EnginePatchVersion *string
// The engine version
EngineVersion *string
// Specifies the name of the parameter group family to which the engine default
// parameters apply.
ParameterGroupFamily *string
noSmithyDocumentSerde
}
// Represents a single occurrence of something interesting within the system. Some
// examples of events are creating a cluster or adding or removing a node.
type Event struct {
// The date and time when the event occurred.
Date *time.Time
// The text of the event.
Message *string
// The name for the source of the event. For example, if the event occurred at the
// cluster level, the identifier would be the name of the cluster.
SourceName *string
// Specifies the origin of this event - a cluster, a parameter group, a security
// group, etc.
SourceType SourceType
noSmithyDocumentSerde
}
// Used to streamline results of a search based on the property being filtered.
type Filter struct {
// The property being filtered. For example, UserName.
//
// This member is required.
Name *string
// The property values to filter on. For example, "user-123".
//
// This member is required.
Values []string
noSmithyDocumentSerde
}
// Represents an individual node within a cluster. Each node runs its own instance
// of the cluster's protocol-compliant caching software.
type Node struct {
// The Availability Zone in which the node resides
AvailabilityZone *string
// The date and time when the node was created.
CreateTime *time.Time
// The hostname for connecting to this node.
Endpoint *Endpoint
// The node identifier. A node name is a numeric identifier (0001, 0002, etc.).
// The combination of cluster name, shard name and node name uniquely identifies
// every node used in a customer's Amazon account.
Name *string
// The status of the service update on the node
Status *string
noSmithyDocumentSerde
}
// Describes an individual setting that controls some aspect of MemoryDB behavior.
type Parameter struct {
// The valid range of values for the parameter.
AllowedValues *string
// The parameter's data type
DataType *string
// A description of the parameter
Description *string
// The earliest engine version to which the parameter can apply.
MinimumEngineVersion *string
// The name of the parameter
Name *string
// The value of the parameter
Value *string
noSmithyDocumentSerde
}
// Represents the output of a CreateParameterGroup operation. A parameter group
// represents a combination of specific values for the parameters that are passed
// to the engine software during startup.
type ParameterGroup struct {
// The Amazon Resource Name (ARN) of the parameter group
ARN *string
// A description of the parameter group
Description *string
// The name of the parameter group family that this parameter group is compatible
// with.
Family *string
// The name of the parameter group
Name *string
noSmithyDocumentSerde
}
// Describes a name-value pair that is used to update the value of a parameter.
type ParameterNameValue struct {
// The name of the parameter
ParameterName *string
// The value of the parameter
ParameterValue *string
noSmithyDocumentSerde
}
// Update action that has yet to be processed for the corresponding apply/stop
// request
type PendingModifiedServiceUpdate struct {
// The unique ID of the service update
ServiceUpdateName *string
// The status of the service update
Status ServiceUpdateStatus
noSmithyDocumentSerde
}
// The recurring charge to run this reserved node.
type RecurringCharge struct {
// The amount of the recurring charge to run this reserved node.
RecurringChargeAmount float64
// The frequency of the recurring price charged to run this reserved node.
RecurringChargeFrequency *string
noSmithyDocumentSerde
}
// A request to configure the number of replicas in a shard
type ReplicaConfigurationRequest struct {
// The number of replicas to scale up or down to
ReplicaCount int32
noSmithyDocumentSerde
}
// Represents the output of a PurchaseReservedNodesOffering operation.
type ReservedNode struct {
// The Amazon Resource Name (ARN) of the reserved node.
ARN *string
// The duration of the reservation in seconds.
Duration int32
// The fixed price charged for this reserved node.
FixedPrice float64
// The number of nodes that have been reserved.
NodeCount int32
// The node type for the reserved nodes.
NodeType *string
// The offering type of this reserved node.
OfferingType *string
// The recurring price charged to run this reserved node.
RecurringCharges []RecurringCharge
// A customer-specified identifier to track this reservation.
ReservationId *string
// The ID of the reserved node offering to purchase.
ReservedNodesOfferingId *string
// The time the reservation started.
StartTime *time.Time
// The state of the reserved node.
State *string
noSmithyDocumentSerde
}
// The offering type of this node.
type ReservedNodesOffering struct {
// The duration of the reservation in seconds.
Duration int32
// The fixed price charged for this reserved node.
FixedPrice float64
// The node type for the reserved nodes. For more information, see Supported node
// types (https://docs.aws.amazon.com/memorydb/latest/devguide/nodes.reserved.html#reserved-nodes-supported)
// .
NodeType *string
// The offering type of this reserved node.
OfferingType *string
// The recurring price charged to run this reserved node.
RecurringCharges []RecurringCharge
// The offering identifier.
ReservedNodesOfferingId *string
noSmithyDocumentSerde
}
// The status of the online resharding
type ReshardingStatus struct {
// The status of the online resharding slot migration
SlotMigration *SlotMigration
noSmithyDocumentSerde
}
// Represents a single security group and its status.
type SecurityGroupMembership struct {
// The identifier of the security group.
SecurityGroupId *string
// The status of the security group membership. The status changes whenever a
// security group is modified, or when the security groups assigned to a cluster
// are modified.
Status *string
noSmithyDocumentSerde
}
// An update that you can apply to your MemoryDB clusters.
type ServiceUpdate struct {
// The date at which the service update will be automatically applied
AutoUpdateStartDate *time.Time
// The name of the cluster to which the service update applies
ClusterName *string
// Provides details of the service update
Description *string
// A list of nodes updated by the service update
NodesUpdated *string
// The date when the service update is initially available
ReleaseDate *time.Time
// The unique ID of the service update
ServiceUpdateName *string
// The status of the service update
Status ServiceUpdateStatus
// Reflects the nature of the service update
Type ServiceUpdateType
noSmithyDocumentSerde
}
// A request to apply a service update
type ServiceUpdateRequest struct {
// The unique ID of the service update
ServiceUpdateNameToApply *string
noSmithyDocumentSerde
}
// Represents a collection of nodes in a cluster. One node in the node group is
// the read/write primary node. All the other nodes are read-only Replica nodes.
type Shard struct {
// The name of the shard
Name *string
// A list containing information about individual nodes within the shard
Nodes []Node
// The number of nodes in the shard
NumberOfNodes *int32
// The keyspace for this shard.
Slots *string
// The current state of this replication group - creating, available, modifying,
// deleting.
Status *string
noSmithyDocumentSerde
}
// Shard configuration options. Each shard configuration has the following: Slots
// and ReplicaCount.
type ShardConfiguration struct {
// The number of read replica nodes in this shard.
ReplicaCount *int32
// A string that specifies the keyspace for a particular node group. Keyspaces
// range from 0 to 16,383. The string is in the format startkey-endkey.
Slots *string
noSmithyDocumentSerde
}
// A request to configure the sharding properties of a cluster
type ShardConfigurationRequest struct {
// The number of shards in the cluster
ShardCount int32
noSmithyDocumentSerde
}
// Provides details of a shard in a snapshot
type ShardDetail struct {
// The configuration details of the shard
Configuration *ShardConfiguration
// The name of the shard
Name *string
// The size of the shard's snapshot
Size *string
// The date and time that the shard's snapshot was created
SnapshotCreationTime *time.Time
noSmithyDocumentSerde
}
// Represents the progress of an online resharding operation.
type SlotMigration struct {
// The percentage of the slot migration that is complete.
ProgressPercentage float64
noSmithyDocumentSerde
}
// Represents a copy of an entire cluster as of the time when the snapshot was
// taken.
type Snapshot struct {
// The ARN (Amazon Resource Name) of the snapshot.
ARN *string
// The configuration of the cluster from which the snapshot was taken
ClusterConfiguration *ClusterConfiguration
// Enables data tiering. Data tiering is only supported for clusters using the
// r6gd node type. This parameter must be set when using r6gd nodes. For more
// information, see Data tiering (https://docs.aws.amazon.com/memorydb/latest/devguide/data-tiering.html)
// .
DataTiering DataTieringStatus
// The ID of the KMS key used to encrypt the snapshot.
KmsKeyId *string
// The name of the snapshot
Name *string
// Indicates whether the snapshot is from an automatic backup (automated) or was
// created manually (manual).
Source *string
// The status of the snapshot. Valid values: creating | available | restoring |
// copying | deleting.
Status *string
noSmithyDocumentSerde
}
// Represents the subnet associated with a cluster. This parameter refers to
// subnets defined in Amazon Virtual Private Cloud (Amazon VPC) and used with
// MemoryDB.
type Subnet struct {
// The Availability Zone where the subnet resides
AvailabilityZone *AvailabilityZone
// The unique identifier for the subnet.
Identifier *string
noSmithyDocumentSerde
}
// Represents the output of one of the following operations:
// - CreateSubnetGroup
// - UpdateSubnetGroup
//
// A subnet group is a collection of subnets (typically private) that you can
// designate for your clusters running in an Amazon Virtual Private Cloud (VPC)
// environment.
type SubnetGroup struct {
// The ARN (Amazon Resource Name) of the subnet group.
ARN *string
// A description of the subnet group
Description *string
// The name of the subnet group
Name *string
// A list of subnets associated with the subnet group.
Subnets []Subnet
// The Amazon Virtual Private Cloud identifier (VPC ID) of the subnet group.
VpcId *string
noSmithyDocumentSerde
}
// A tag that can be added to an MemoryDB resource. Tags are composed of a
// Key/Value pair. You can use tags to categorize and track all your MemoryDB
// resources. When you add or remove tags on clusters, those actions will be
// replicated to all nodes in the cluster. A tag with a null Value is permitted.
// For more information, see Tagging your MemoryDB resources (https://docs.aws.amazon.com/MemoryDB/latest/devguide/tagging-resources.html)
type Tag struct {
// The key for the tag. May not be null.
Key *string
// The tag's value. May be null.
Value *string
noSmithyDocumentSerde
}
// A cluster whose updates have failed
type UnprocessedCluster struct {
// The name of the cluster
ClusterName *string
// The error message associated with the update failure
ErrorMessage *string
// The error type associated with the update failure
ErrorType *string
noSmithyDocumentSerde
}
// You create users and assign them specific permissions by using an access
// string. You assign the users to Access Control Lists aligned with a specific
// role (administrators, human resources) that are then deployed to one or more
// MemoryDB clusters.
type User struct {
// The names of the Access Control Lists to which the user belongs
ACLNames []string
// The Amazon Resource Name (ARN) of the user.
ARN *string
// Access permissions string used for this user.
AccessString *string
// Denotes whether the user requires a password to authenticate.
Authentication *Authentication
// The minimum engine version supported for the user
MinimumEngineVersion *string
// The name of the user
Name *string
// Indicates the user status. Can be "active", "modifying" or "deleting".
Status *string
noSmithyDocumentSerde
}
type noSmithyDocumentSerde = smithydocument.NoSerde
| 774 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
import (
"context"
cryptorand "crypto/rand"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/aws/defaults"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/retry"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources"
smithy "github.com/aws/smithy-go"
smithydocument "github.com/aws/smithy-go/document"
"github.com/aws/smithy-go/logging"
"github.com/aws/smithy-go/middleware"
smithyrand "github.com/aws/smithy-go/rand"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net"
"net/http"
"time"
)
const ServiceID = "mgn"
const ServiceAPIVersion = "2020-02-26"
// Client provides the API client to make operations call for Application
// Migration Service.
type Client struct {
options Options
}
// New returns an initialized Client based on the functional options. Provide
// additional functional options to further configure the behavior of the client,
// such as changing the client's endpoint or adding custom middleware behavior.
func New(options Options, optFns ...func(*Options)) *Client {
options = options.Copy()
resolveDefaultLogger(&options)
setResolvedDefaultsMode(&options)
resolveRetryer(&options)
resolveHTTPClient(&options)
resolveHTTPSignerV4(&options)
resolveDefaultEndpointConfiguration(&options)
resolveIdempotencyTokenProvider(&options)
for _, fn := range optFns {
fn(&options)
}
client := &Client{
options: options,
}
return client
}
type Options struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// Configures the events that will be sent to the configured logger.
ClientLogMode aws.ClientLogMode
// The credentials object to use when signing requests.
Credentials aws.CredentialsProvider
// The configuration DefaultsMode that the SDK should use when constructing the
// clients initial default settings.
DefaultsMode aws.DefaultsMode
// The endpoint options to be used when attempting to resolve an endpoint.
EndpointOptions EndpointResolverOptions
// The service endpoint resolver.
EndpointResolver EndpointResolver
// Signature Version 4 (SigV4) Signer
HTTPSignerV4 HTTPSignerV4
// Provides idempotency tokens values that will be automatically populated into
// idempotent API operations.
IdempotencyTokenProvider IdempotencyTokenProvider
// The logger writer interface to write logging messages to.
Logger logging.Logger
// The region to send requests to. (Required)
Region string
// RetryMaxAttempts specifies the maximum number attempts an API client will call
// an operation that fails with a retryable error. A value of 0 is ignored, and
// will not be used to configure the API client created default retryer, or modify
// per operation call's retry max attempts. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. If specified in an operation call's functional
// options with a value that is different than the constructed client's Options,
// the Client's Retryer will be wrapped to use the operation's specific
// RetryMaxAttempts value.
RetryMaxAttempts int
// RetryMode specifies the retry mode the API client will be created with, if
// Retryer option is not also specified. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. Currently does not support per operation call
// overrides, may in the future.
RetryMode aws.RetryMode
// Retryer guides how HTTP requests should be retried in case of recoverable
// failures. When nil the API client will use a default retryer. The kind of
// default retry created by the API client can be changed with the RetryMode
// option.
Retryer aws.Retryer
// The RuntimeEnvironment configuration, only populated if the DefaultsMode is set
// to DefaultsModeAuto and is initialized using config.LoadDefaultConfig . You
// should not populate this structure programmatically, or rely on the values here
// within your applications.
RuntimeEnvironment aws.RuntimeEnvironment
// The initial DefaultsMode used when the client options were constructed. If the
// DefaultsMode was set to aws.DefaultsModeAuto this will store what the resolved
// value was at that point in time. Currently does not support per operation call
// overrides, may in the future.
resolvedDefaultsMode aws.DefaultsMode
// The HTTP client to invoke API calls with. Defaults to client's default HTTP
// implementation if nil.
HTTPClient HTTPClient
}
// WithAPIOptions returns a functional option for setting the Client's APIOptions
// option.
func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options) {
return func(o *Options) {
o.APIOptions = append(o.APIOptions, optFns...)
}
}
// WithEndpointResolver returns a functional option for setting the Client's
// EndpointResolver option.
func WithEndpointResolver(v EndpointResolver) func(*Options) {
return func(o *Options) {
o.EndpointResolver = v
}
}
type HTTPClient interface {
Do(*http.Request) (*http.Response, error)
}
// Copy creates a clone where the APIOptions list is deep copied.
func (o Options) Copy() Options {
to := o
to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions))
copy(to.APIOptions, o.APIOptions)
return to
}
func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) {
ctx = middleware.ClearStackValues(ctx)
stack := middleware.NewStack(opID, smithyhttp.NewStackRequest)
options := c.options.Copy()
for _, fn := range optFns {
fn(&options)
}
finalizeRetryMaxAttemptOptions(&options, *c)
finalizeClientEndpointResolverOptions(&options)
for _, fn := range stackFns {
if err := fn(stack, options); err != nil {
return nil, metadata, err
}
}
for _, fn := range options.APIOptions {
if err := fn(stack); err != nil {
return nil, metadata, err
}
}
handler := middleware.DecorateHandler(smithyhttp.NewClientHandler(options.HTTPClient), stack)
result, metadata, err = handler.Handle(ctx, params)
if err != nil {
err = &smithy.OperationError{
ServiceID: ServiceID,
OperationName: opID,
Err: err,
}
}
return result, metadata, err
}
type noSmithyDocumentSerde = smithydocument.NoSerde
func resolveDefaultLogger(o *Options) {
if o.Logger != nil {
return
}
o.Logger = logging.Nop{}
}
func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error {
return middleware.AddSetLoggerMiddleware(stack, o.Logger)
}
func setResolvedDefaultsMode(o *Options) {
if len(o.resolvedDefaultsMode) > 0 {
return
}
var mode aws.DefaultsMode
mode.SetFromString(string(o.DefaultsMode))
if mode == aws.DefaultsModeAuto {
mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment)
}
o.resolvedDefaultsMode = mode
}
// NewFromConfig returns a new client from the provided config.
func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client {
opts := Options{
Region: cfg.Region,
DefaultsMode: cfg.DefaultsMode,
RuntimeEnvironment: cfg.RuntimeEnvironment,
HTTPClient: cfg.HTTPClient,
Credentials: cfg.Credentials,
APIOptions: cfg.APIOptions,
Logger: cfg.Logger,
ClientLogMode: cfg.ClientLogMode,
}
resolveAWSRetryerProvider(cfg, &opts)
resolveAWSRetryMaxAttempts(cfg, &opts)
resolveAWSRetryMode(cfg, &opts)
resolveAWSEndpointResolver(cfg, &opts)
resolveUseDualStackEndpoint(cfg, &opts)
resolveUseFIPSEndpoint(cfg, &opts)
return New(opts, optFns...)
}
func resolveHTTPClient(o *Options) {
var buildable *awshttp.BuildableClient
if o.HTTPClient != nil {
var ok bool
buildable, ok = o.HTTPClient.(*awshttp.BuildableClient)
if !ok {
return
}
} else {
buildable = awshttp.NewBuildableClient()
}
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) {
if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok {
dialer.Timeout = dialerTimeout
}
})
buildable = buildable.WithTransportOptions(func(transport *http.Transport) {
if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok {
transport.TLSHandshakeTimeout = tlsHandshakeTimeout
}
})
}
o.HTTPClient = buildable
}
func resolveRetryer(o *Options) {
if o.Retryer != nil {
return
}
if len(o.RetryMode) == 0 {
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
o.RetryMode = modeConfig.RetryMode
}
}
if len(o.RetryMode) == 0 {
o.RetryMode = aws.RetryModeStandard
}
var standardOptions []func(*retry.StandardOptions)
if v := o.RetryMaxAttempts; v != 0 {
standardOptions = append(standardOptions, func(so *retry.StandardOptions) {
so.MaxAttempts = v
})
}
switch o.RetryMode {
case aws.RetryModeAdaptive:
var adaptiveOptions []func(*retry.AdaptiveModeOptions)
if len(standardOptions) != 0 {
adaptiveOptions = append(adaptiveOptions, func(ao *retry.AdaptiveModeOptions) {
ao.StandardOptions = append(ao.StandardOptions, standardOptions...)
})
}
o.Retryer = retry.NewAdaptiveMode(adaptiveOptions...)
default:
o.Retryer = retry.NewStandard(standardOptions...)
}
}
func resolveAWSRetryerProvider(cfg aws.Config, o *Options) {
if cfg.Retryer == nil {
return
}
o.Retryer = cfg.Retryer()
}
func resolveAWSRetryMode(cfg aws.Config, o *Options) {
if len(cfg.RetryMode) == 0 {
return
}
o.RetryMode = cfg.RetryMode
}
func resolveAWSRetryMaxAttempts(cfg aws.Config, o *Options) {
if cfg.RetryMaxAttempts == 0 {
return
}
o.RetryMaxAttempts = cfg.RetryMaxAttempts
}
func finalizeRetryMaxAttemptOptions(o *Options, client Client) {
if v := o.RetryMaxAttempts; v == 0 || v == client.options.RetryMaxAttempts {
return
}
o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts)
}
func resolveAWSEndpointResolver(cfg aws.Config, o *Options) {
if cfg.EndpointResolver == nil && cfg.EndpointResolverWithOptions == nil {
return
}
o.EndpointResolver = withEndpointResolver(cfg.EndpointResolver, cfg.EndpointResolverWithOptions, NewDefaultEndpointResolver())
}
func addClientUserAgent(stack *middleware.Stack) error {
return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "mgn", goModuleVersion)(stack)
}
func addHTTPSignerV4Middleware(stack *middleware.Stack, o Options) error {
mw := v4.NewSignHTTPRequestMiddleware(v4.SignHTTPRequestMiddlewareOptions{
CredentialsProvider: o.Credentials,
Signer: o.HTTPSignerV4,
LogSigning: o.ClientLogMode.IsSigning(),
})
return stack.Finalize.Add(mw, middleware.After)
}
type HTTPSignerV4 interface {
SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
}
func resolveHTTPSignerV4(o *Options) {
if o.HTTPSignerV4 != nil {
return
}
o.HTTPSignerV4 = newDefaultV4Signer(*o)
}
func newDefaultV4Signer(o Options) *v4.Signer {
return v4.NewSigner(func(so *v4.SignerOptions) {
so.Logger = o.Logger
so.LogSigning = o.ClientLogMode.IsSigning()
})
}
func resolveIdempotencyTokenProvider(o *Options) {
if o.IdempotencyTokenProvider != nil {
return
}
o.IdempotencyTokenProvider = smithyrand.NewUUIDIdempotencyToken(cryptorand.Reader)
}
func addRetryMiddlewares(stack *middleware.Stack, o Options) error {
mo := retry.AddRetryMiddlewaresOptions{
Retryer: o.Retryer,
LogRetryAttempts: o.ClientLogMode.IsRetries(),
}
return retry.AddRetryMiddlewares(stack, mo)
}
// resolves dual-stack endpoint configuration
func resolveUseDualStackEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseDualStackEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseDualStackEndpoint = value
}
return nil
}
// resolves FIPS endpoint configuration
func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseFIPSEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseFIPSEndpoint = value
}
return nil
}
// IdempotencyTokenProvider interface for providing idempotency token
type IdempotencyTokenProvider interface {
GetIdempotencyToken() (string, error)
}
func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error {
return awsmiddleware.AddRequestIDRetrieverMiddleware(stack)
}
func addResponseErrorMiddleware(stack *middleware.Stack) error {
return awshttp.AddResponseErrorMiddleware(stack)
}
func addRequestResponseLogging(stack *middleware.Stack, o Options) error {
return stack.Deserialize.Add(&smithyhttp.RequestResponseLogger{
LogRequest: o.ClientLogMode.IsRequest(),
LogRequestWithBody: o.ClientLogMode.IsRequestWithBody(),
LogResponse: o.ClientLogMode.IsResponse(),
LogResponseWithBody: o.ClientLogMode.IsResponseWithBody(),
}, middleware.After)
}
| 455 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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 mgn
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/mgn/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Archive application.
func (c *Client) ArchiveApplication(ctx context.Context, params *ArchiveApplicationInput, optFns ...func(*Options)) (*ArchiveApplicationOutput, error) {
if params == nil {
params = &ArchiveApplicationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ArchiveApplication", params, optFns, c.addOperationArchiveApplicationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ArchiveApplicationOutput)
out.ResultMetadata = metadata
return out, nil
}
type ArchiveApplicationInput struct {
// Application ID.
//
// This member is required.
ApplicationID *string
noSmithyDocumentSerde
}
type ArchiveApplicationOutput struct {
// Application aggregated status.
ApplicationAggregatedStatus *types.ApplicationAggregatedStatus
// Application ID.
ApplicationID *string
// Application ARN.
Arn *string
// Application creation dateTime.
CreationDateTime *string
// Application description.
Description *string
// Application archival status.
IsArchived *bool
// Application last modified dateTime.
LastModifiedDateTime *string
// Application name.
Name *string
// Application tags.
Tags map[string]string
// Application wave ID.
WaveID *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationArchiveApplicationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpArchiveApplication{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpArchiveApplication{}, 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 = addOpArchiveApplicationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opArchiveApplication(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_opArchiveApplication(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "ArchiveApplication",
}
}
| 152 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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/mgn/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Archive wave.
func (c *Client) ArchiveWave(ctx context.Context, params *ArchiveWaveInput, optFns ...func(*Options)) (*ArchiveWaveOutput, error) {
if params == nil {
params = &ArchiveWaveInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ArchiveWave", params, optFns, c.addOperationArchiveWaveMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ArchiveWaveOutput)
out.ResultMetadata = metadata
return out, nil
}
type ArchiveWaveInput struct {
// Wave ID.
//
// This member is required.
WaveID *string
noSmithyDocumentSerde
}
type ArchiveWaveOutput struct {
// Wave ARN.
Arn *string
// Wave creation dateTime.
CreationDateTime *string
// Wave description.
Description *string
// Wave archival status.
IsArchived *bool
// Wave last modified dateTime.
LastModifiedDateTime *string
// Wave name.
Name *string
// Wave tags.
Tags map[string]string
// Wave aggregated status.
WaveAggregatedStatus *types.WaveAggregatedStatus
// Wave ID.
WaveID *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationArchiveWaveMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpArchiveWave{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpArchiveWave{}, 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 = addOpArchiveWaveValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opArchiveWave(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_opArchiveWave(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "ArchiveWave",
}
}
| 149 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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"
)
// Associate applications to wave.
func (c *Client) AssociateApplications(ctx context.Context, params *AssociateApplicationsInput, optFns ...func(*Options)) (*AssociateApplicationsOutput, error) {
if params == nil {
params = &AssociateApplicationsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "AssociateApplications", params, optFns, c.addOperationAssociateApplicationsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*AssociateApplicationsOutput)
out.ResultMetadata = metadata
return out, nil
}
type AssociateApplicationsInput struct {
// Application IDs list.
//
// This member is required.
ApplicationIDs []string
// Wave ID.
//
// This member is required.
WaveID *string
noSmithyDocumentSerde
}
type AssociateApplicationsOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationAssociateApplicationsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpAssociateApplications{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpAssociateApplications{}, 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 = addOpAssociateApplicationsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opAssociateApplications(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_opAssociateApplications(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "AssociateApplications",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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"
)
// Associate source servers to application.
func (c *Client) AssociateSourceServers(ctx context.Context, params *AssociateSourceServersInput, optFns ...func(*Options)) (*AssociateSourceServersOutput, error) {
if params == nil {
params = &AssociateSourceServersInput{}
}
result, metadata, err := c.invokeOperation(ctx, "AssociateSourceServers", params, optFns, c.addOperationAssociateSourceServersMiddlewares)
if err != nil {
return nil, err
}
out := result.(*AssociateSourceServersOutput)
out.ResultMetadata = metadata
return out, nil
}
type AssociateSourceServersInput struct {
// Application ID.
//
// This member is required.
ApplicationID *string
// Source server IDs list.
//
// This member is required.
SourceServerIDs []string
noSmithyDocumentSerde
}
type AssociateSourceServersOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationAssociateSourceServersMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpAssociateSourceServers{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpAssociateSourceServers{}, 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 = addOpAssociateSourceServersValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opAssociateSourceServers(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_opAssociateSourceServers(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "AssociateSourceServers",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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/mgn/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Allows the user to set the SourceServer.LifeCycle.state property for specific
// Source Server IDs to one of the following: READY_FOR_TEST or READY_FOR_CUTOVER.
// This command only works if the Source Server is already launchable
// (dataReplicationInfo.lagDuration is not null.)
func (c *Client) ChangeServerLifeCycleState(ctx context.Context, params *ChangeServerLifeCycleStateInput, optFns ...func(*Options)) (*ChangeServerLifeCycleStateOutput, error) {
if params == nil {
params = &ChangeServerLifeCycleStateInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ChangeServerLifeCycleState", params, optFns, c.addOperationChangeServerLifeCycleStateMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ChangeServerLifeCycleStateOutput)
out.ResultMetadata = metadata
return out, nil
}
type ChangeServerLifeCycleStateInput struct {
// The request to change the source server migration lifecycle state.
//
// This member is required.
LifeCycle *types.ChangeServerLifeCycleStateSourceServerLifecycle
// The request to change the source server migration lifecycle state by source
// server ID.
//
// This member is required.
SourceServerID *string
noSmithyDocumentSerde
}
type ChangeServerLifeCycleStateOutput struct {
// Source server application ID.
ApplicationID *string
// Source server ARN.
Arn *string
// Source server data replication info.
DataReplicationInfo *types.DataReplicationInfo
// Source server fqdn for action framework.
FqdnForActionFramework *string
// Source server archived status.
IsArchived *bool
// Source server launched instance.
LaunchedInstance *types.LaunchedInstance
// Source server lifecycle state.
LifeCycle *types.LifeCycle
// Source server replication type.
ReplicationType types.ReplicationType
// Source server properties.
SourceProperties *types.SourceProperties
// Source server ID.
SourceServerID *string
// Source server Tags.
Tags map[string]string
// Source server user provided ID.
UserProvidedID *string
// Source server vCenter client id.
VcenterClientID *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationChangeServerLifeCycleStateMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpChangeServerLifeCycleState{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpChangeServerLifeCycleState{}, 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 = addOpChangeServerLifeCycleStateValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opChangeServerLifeCycleState(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_opChangeServerLifeCycleState(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "ChangeServerLifeCycleState",
}
}
| 170 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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/mgn/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Create application.
func (c *Client) CreateApplication(ctx context.Context, params *CreateApplicationInput, optFns ...func(*Options)) (*CreateApplicationOutput, error) {
if params == nil {
params = &CreateApplicationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateApplication", params, optFns, c.addOperationCreateApplicationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateApplicationOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateApplicationInput struct {
// Application name.
//
// This member is required.
Name *string
// Application description.
Description *string
// Application tags.
Tags map[string]string
noSmithyDocumentSerde
}
type CreateApplicationOutput struct {
// Application aggregated status.
ApplicationAggregatedStatus *types.ApplicationAggregatedStatus
// Application ID.
ApplicationID *string
// Application ARN.
Arn *string
// Application creation dateTime.
CreationDateTime *string
// Application description.
Description *string
// Application archival status.
IsArchived *bool
// Application last modified dateTime.
LastModifiedDateTime *string
// Application name.
Name *string
// Application tags.
Tags map[string]string
// Application wave ID.
WaveID *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateApplicationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateApplication{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateApplication{}, 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 = addOpCreateApplicationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateApplication(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_opCreateApplication(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "CreateApplication",
}
}
| 158 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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/mgn/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a new Launch Configuration Template.
func (c *Client) CreateLaunchConfigurationTemplate(ctx context.Context, params *CreateLaunchConfigurationTemplateInput, optFns ...func(*Options)) (*CreateLaunchConfigurationTemplateOutput, error) {
if params == nil {
params = &CreateLaunchConfigurationTemplateInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateLaunchConfigurationTemplate", params, optFns, c.addOperationCreateLaunchConfigurationTemplateMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateLaunchConfigurationTemplateOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateLaunchConfigurationTemplateInput struct {
// Associate public Ip address.
AssociatePublicIpAddress *bool
// Launch configuration template boot mode.
BootMode types.BootMode
// Copy private Ip.
CopyPrivateIp *bool
// Copy tags.
CopyTags *bool
// Enable map auto tagging.
EnableMapAutoTagging *bool
// Large volume config.
LargeVolumeConf *types.LaunchTemplateDiskConf
// Launch disposition.
LaunchDisposition types.LaunchDisposition
// Configure Licensing.
Licensing *types.Licensing
// Launch configuration template map auto tagging MPE ID.
MapAutoTaggingMpeID *string
// Launch configuration template post launch actions.
PostLaunchActions *types.PostLaunchActions
// Small volume config.
SmallVolumeConf *types.LaunchTemplateDiskConf
// Small volume maximum size.
SmallVolumeMaxSize int64
// Request to associate tags during creation of a Launch Configuration Template.
Tags map[string]string
// Target instance type right-sizing method.
TargetInstanceTypeRightSizingMethod types.TargetInstanceTypeRightSizingMethod
noSmithyDocumentSerde
}
type CreateLaunchConfigurationTemplateOutput struct {
// ID of the Launch Configuration Template.
//
// This member is required.
LaunchConfigurationTemplateID *string
// ARN of the Launch Configuration Template.
Arn *string
// Associate public Ip address.
AssociatePublicIpAddress *bool
// Launch configuration template boot mode.
BootMode types.BootMode
// Copy private Ip.
CopyPrivateIp *bool
// Copy tags.
CopyTags *bool
// EC2 launch template ID.
Ec2LaunchTemplateID *string
// Enable map auto tagging.
EnableMapAutoTagging *bool
// Large volume config.
LargeVolumeConf *types.LaunchTemplateDiskConf
// Launch disposition.
LaunchDisposition types.LaunchDisposition
// Configure Licensing.
Licensing *types.Licensing
// Launch configuration template map auto tagging MPE ID.
MapAutoTaggingMpeID *string
// Post Launch Actions of the Launch Configuration Template.
PostLaunchActions *types.PostLaunchActions
// Small volume config.
SmallVolumeConf *types.LaunchTemplateDiskConf
// Small volume maximum size.
SmallVolumeMaxSize int64
// Tags of the Launch Configuration Template.
Tags map[string]string
// Target instance type right-sizing method.
TargetInstanceTypeRightSizingMethod types.TargetInstanceTypeRightSizingMethod
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateLaunchConfigurationTemplateMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateLaunchConfigurationTemplate{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateLaunchConfigurationTemplate{}, 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 = addOpCreateLaunchConfigurationTemplateValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateLaunchConfigurationTemplate(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_opCreateLaunchConfigurationTemplate(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "CreateLaunchConfigurationTemplate",
}
}
| 212 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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/mgn/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a new ReplicationConfigurationTemplate.
func (c *Client) CreateReplicationConfigurationTemplate(ctx context.Context, params *CreateReplicationConfigurationTemplateInput, optFns ...func(*Options)) (*CreateReplicationConfigurationTemplateOutput, error) {
if params == nil {
params = &CreateReplicationConfigurationTemplateInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateReplicationConfigurationTemplate", params, optFns, c.addOperationCreateReplicationConfigurationTemplateMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateReplicationConfigurationTemplateOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateReplicationConfigurationTemplateInput struct {
// Request to associate the default Application Migration Service Security group
// with the Replication Settings template.
//
// This member is required.
AssociateDefaultSecurityGroup *bool
// Request to configure bandwidth throttling during Replication Settings template
// creation.
//
// This member is required.
BandwidthThrottling int64
// Request to create Public IP during Replication Settings template creation.
//
// This member is required.
CreatePublicIP *bool
// Request to configure data plane routing during Replication Settings template
// creation.
//
// This member is required.
DataPlaneRouting types.ReplicationConfigurationDataPlaneRouting
// Request to configure the default large staging disk EBS volume type during
// Replication Settings template creation.
//
// This member is required.
DefaultLargeStagingDiskType types.ReplicationConfigurationDefaultLargeStagingDiskType
// Request to configure EBS encryption during Replication Settings template
// creation.
//
// This member is required.
EbsEncryption types.ReplicationConfigurationEbsEncryption
// Request to configure the Replication Server instance type during Replication
// Settings template creation.
//
// This member is required.
ReplicationServerInstanceType *string
// Request to configure the Replication Server Security group ID during
// Replication Settings template creation.
//
// This member is required.
ReplicationServersSecurityGroupsIDs []string
// Request to configure the Staging Area subnet ID during Replication Settings
// template creation.
//
// This member is required.
StagingAreaSubnetId *string
// Request to configure Staging Area tags during Replication Settings template
// creation.
//
// This member is required.
StagingAreaTags map[string]string
// Request to use Dedicated Replication Servers during Replication Settings
// template creation.
//
// This member is required.
UseDedicatedReplicationServer *bool
// Request to configure an EBS encryption key during Replication Settings template
// creation.
EbsEncryptionKeyArn *string
// Request to configure tags during Replication Settings template creation.
Tags map[string]string
noSmithyDocumentSerde
}
type CreateReplicationConfigurationTemplateOutput struct {
// Replication Configuration template ID.
//
// This member is required.
ReplicationConfigurationTemplateID *string
// Replication Configuration template ARN.
Arn *string
// Replication Configuration template associate default Application Migration
// Service Security group.
AssociateDefaultSecurityGroup *bool
// Replication Configuration template bandwidth throttling.
BandwidthThrottling int64
// Replication Configuration template create Public IP.
CreatePublicIP *bool
// Replication Configuration template data plane routing.
DataPlaneRouting types.ReplicationConfigurationDataPlaneRouting
// Replication Configuration template use default large Staging Disk type.
DefaultLargeStagingDiskType types.ReplicationConfigurationDefaultLargeStagingDiskType
// Replication Configuration template EBS encryption.
EbsEncryption types.ReplicationConfigurationEbsEncryption
// Replication Configuration template EBS encryption key ARN.
EbsEncryptionKeyArn *string
// Replication Configuration template server instance type.
ReplicationServerInstanceType *string
// Replication Configuration template server Security Groups IDs.
ReplicationServersSecurityGroupsIDs []string
// Replication Configuration template Staging Area subnet ID.
StagingAreaSubnetId *string
// Replication Configuration template Staging Area Tags.
StagingAreaTags map[string]string
// Replication Configuration template Tags.
Tags map[string]string
// Replication Configuration template use Dedicated Replication Server.
UseDedicatedReplicationServer *bool
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateReplicationConfigurationTemplateMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateReplicationConfigurationTemplate{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateReplicationConfigurationTemplate{}, 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 = addOpCreateReplicationConfigurationTemplateValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateReplicationConfigurationTemplate(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_opCreateReplicationConfigurationTemplate(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "CreateReplicationConfigurationTemplate",
}
}
| 237 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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/mgn/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Create wave.
func (c *Client) CreateWave(ctx context.Context, params *CreateWaveInput, optFns ...func(*Options)) (*CreateWaveOutput, error) {
if params == nil {
params = &CreateWaveInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateWave", params, optFns, c.addOperationCreateWaveMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateWaveOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateWaveInput struct {
// Wave name.
//
// This member is required.
Name *string
// Wave description.
Description *string
// Wave tags.
Tags map[string]string
noSmithyDocumentSerde
}
type CreateWaveOutput struct {
// Wave ARN.
Arn *string
// Wave creation dateTime.
CreationDateTime *string
// Wave description.
Description *string
// Wave archival status.
IsArchived *bool
// Wave last modified dateTime.
LastModifiedDateTime *string
// Wave name.
Name *string
// Wave tags.
Tags map[string]string
// Wave aggregated status.
WaveAggregatedStatus *types.WaveAggregatedStatus
// Wave ID.
WaveID *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateWaveMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateWave{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateWave{}, 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 = addOpCreateWaveValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateWave(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_opCreateWave(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "CreateWave",
}
}
| 155 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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"
)
// Delete application.
func (c *Client) DeleteApplication(ctx context.Context, params *DeleteApplicationInput, optFns ...func(*Options)) (*DeleteApplicationOutput, error) {
if params == nil {
params = &DeleteApplicationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteApplication", params, optFns, c.addOperationDeleteApplicationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteApplicationOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteApplicationInput struct {
// Application ID.
//
// This member is required.
ApplicationID *string
noSmithyDocumentSerde
}
type DeleteApplicationOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteApplicationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteApplication{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteApplication{}, 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 = addOpDeleteApplicationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteApplication(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_opDeleteApplication(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "DeleteApplication",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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 single Job by ID.
func (c *Client) DeleteJob(ctx context.Context, params *DeleteJobInput, optFns ...func(*Options)) (*DeleteJobOutput, error) {
if params == nil {
params = &DeleteJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteJob", params, optFns, c.addOperationDeleteJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteJobInput struct {
// Request to delete Job from service by Job ID.
//
// This member is required.
JobID *string
noSmithyDocumentSerde
}
type DeleteJobOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteJob{}, 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 = addOpDeleteJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteJob(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_opDeleteJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "DeleteJob",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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 single Launch Configuration Template by ID.
func (c *Client) DeleteLaunchConfigurationTemplate(ctx context.Context, params *DeleteLaunchConfigurationTemplateInput, optFns ...func(*Options)) (*DeleteLaunchConfigurationTemplateOutput, error) {
if params == nil {
params = &DeleteLaunchConfigurationTemplateInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteLaunchConfigurationTemplate", params, optFns, c.addOperationDeleteLaunchConfigurationTemplateMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteLaunchConfigurationTemplateOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteLaunchConfigurationTemplateInput struct {
// ID of resource to be deleted.
//
// This member is required.
LaunchConfigurationTemplateID *string
noSmithyDocumentSerde
}
type DeleteLaunchConfigurationTemplateOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteLaunchConfigurationTemplateMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteLaunchConfigurationTemplate{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteLaunchConfigurationTemplate{}, 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 = addOpDeleteLaunchConfigurationTemplateValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteLaunchConfigurationTemplate(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_opDeleteLaunchConfigurationTemplate(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "DeleteLaunchConfigurationTemplate",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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 single Replication Configuration Template by ID
func (c *Client) DeleteReplicationConfigurationTemplate(ctx context.Context, params *DeleteReplicationConfigurationTemplateInput, optFns ...func(*Options)) (*DeleteReplicationConfigurationTemplateOutput, error) {
if params == nil {
params = &DeleteReplicationConfigurationTemplateInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteReplicationConfigurationTemplate", params, optFns, c.addOperationDeleteReplicationConfigurationTemplateMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteReplicationConfigurationTemplateOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteReplicationConfigurationTemplateInput struct {
// Request to delete Replication Configuration Template from service by
// Replication Configuration Template ID.
//
// This member is required.
ReplicationConfigurationTemplateID *string
noSmithyDocumentSerde
}
type DeleteReplicationConfigurationTemplateOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteReplicationConfigurationTemplateMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteReplicationConfigurationTemplate{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteReplicationConfigurationTemplate{}, 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 = addOpDeleteReplicationConfigurationTemplateValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteReplicationConfigurationTemplate(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_opDeleteReplicationConfigurationTemplate(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "DeleteReplicationConfigurationTemplate",
}
}
| 121 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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 single source server by ID.
func (c *Client) DeleteSourceServer(ctx context.Context, params *DeleteSourceServerInput, optFns ...func(*Options)) (*DeleteSourceServerOutput, error) {
if params == nil {
params = &DeleteSourceServerInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteSourceServer", params, optFns, c.addOperationDeleteSourceServerMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteSourceServerOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteSourceServerInput struct {
// Request to delete Source Server from service by Server ID.
//
// This member is required.
SourceServerID *string
noSmithyDocumentSerde
}
type DeleteSourceServerOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteSourceServerMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteSourceServer{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteSourceServer{}, 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 = addOpDeleteSourceServerValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteSourceServer(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_opDeleteSourceServer(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "DeleteSourceServer",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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 given vCenter client by ID.
func (c *Client) DeleteVcenterClient(ctx context.Context, params *DeleteVcenterClientInput, optFns ...func(*Options)) (*DeleteVcenterClientOutput, error) {
if params == nil {
params = &DeleteVcenterClientInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteVcenterClient", params, optFns, c.addOperationDeleteVcenterClientMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteVcenterClientOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteVcenterClientInput struct {
// ID of resource to be deleted.
//
// This member is required.
VcenterClientID *string
noSmithyDocumentSerde
}
type DeleteVcenterClientOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteVcenterClientMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteVcenterClient{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteVcenterClient{}, 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 = addOpDeleteVcenterClientValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteVcenterClient(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_opDeleteVcenterClient(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "DeleteVcenterClient",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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"
)
// Delete wave.
func (c *Client) DeleteWave(ctx context.Context, params *DeleteWaveInput, optFns ...func(*Options)) (*DeleteWaveOutput, error) {
if params == nil {
params = &DeleteWaveInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteWave", params, optFns, c.addOperationDeleteWaveMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteWaveOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteWaveInput struct {
// Wave ID.
//
// This member is required.
WaveID *string
noSmithyDocumentSerde
}
type DeleteWaveOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteWaveMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDeleteWave{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDeleteWave{}, 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 = addOpDeleteWaveValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteWave(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_opDeleteWave(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "DeleteWave",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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/mgn/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves detailed job log items with paging.
func (c *Client) DescribeJobLogItems(ctx context.Context, params *DescribeJobLogItemsInput, optFns ...func(*Options)) (*DescribeJobLogItemsOutput, error) {
if params == nil {
params = &DescribeJobLogItemsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeJobLogItems", params, optFns, c.addOperationDescribeJobLogItemsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeJobLogItemsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeJobLogItemsInput struct {
// Request to describe Job log job ID.
//
// This member is required.
JobID *string
// Request to describe Job log item maximum results.
MaxResults int32
// Request to describe Job log next token.
NextToken *string
noSmithyDocumentSerde
}
type DescribeJobLogItemsOutput struct {
// Request to describe Job log response items.
Items []types.JobLog
// Request to describe Job log response next token.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeJobLogItemsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeJobLogItems{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeJobLogItems{}, 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 = addOpDescribeJobLogItemsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeJobLogItems(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
}
// DescribeJobLogItemsAPIClient is a client that implements the
// DescribeJobLogItems operation.
type DescribeJobLogItemsAPIClient interface {
DescribeJobLogItems(context.Context, *DescribeJobLogItemsInput, ...func(*Options)) (*DescribeJobLogItemsOutput, error)
}
var _ DescribeJobLogItemsAPIClient = (*Client)(nil)
// DescribeJobLogItemsPaginatorOptions is the paginator options for
// DescribeJobLogItems
type DescribeJobLogItemsPaginatorOptions struct {
// Request to describe Job log item maximum results.
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
}
// DescribeJobLogItemsPaginator is a paginator for DescribeJobLogItems
type DescribeJobLogItemsPaginator struct {
options DescribeJobLogItemsPaginatorOptions
client DescribeJobLogItemsAPIClient
params *DescribeJobLogItemsInput
nextToken *string
firstPage bool
}
// NewDescribeJobLogItemsPaginator returns a new DescribeJobLogItemsPaginator
func NewDescribeJobLogItemsPaginator(client DescribeJobLogItemsAPIClient, params *DescribeJobLogItemsInput, optFns ...func(*DescribeJobLogItemsPaginatorOptions)) *DescribeJobLogItemsPaginator {
if params == nil {
params = &DescribeJobLogItemsInput{}
}
options := DescribeJobLogItemsPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeJobLogItemsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeJobLogItemsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeJobLogItems page.
func (p *DescribeJobLogItemsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeJobLogItemsOutput, 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.DescribeJobLogItems(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_opDescribeJobLogItems(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "DescribeJobLogItems",
}
}
| 222 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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/mgn/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of Jobs. Use the JobsID and fromDate and toData filters to limit
// which jobs are returned. The response is sorted by creationDataTime - latest
// date first. Jobs are normally created by the StartTest, StartCutover, and
// TerminateTargetInstances APIs. Jobs are also created by DiagnosticLaunch and
// TerminateDiagnosticInstances, which are APIs available only to *Support* and
// only used in response to relevant support tickets.
func (c *Client) DescribeJobs(ctx context.Context, params *DescribeJobsInput, optFns ...func(*Options)) (*DescribeJobsOutput, error) {
if params == nil {
params = &DescribeJobsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeJobs", params, optFns, c.addOperationDescribeJobsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeJobsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeJobsInput struct {
// Request to describe Job log filters.
Filters *types.DescribeJobsRequestFilters
// Request to describe job log items by max results.
MaxResults int32
// Request to describe job log items by next token.
NextToken *string
noSmithyDocumentSerde
}
type DescribeJobsOutput struct {
// Request to describe Job log items.
Items []types.Job
// Request to describe Job response by next token.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeJobsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeJobs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeJobs{}, 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_opDescribeJobs(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
}
// DescribeJobsAPIClient is a client that implements the DescribeJobs operation.
type DescribeJobsAPIClient interface {
DescribeJobs(context.Context, *DescribeJobsInput, ...func(*Options)) (*DescribeJobsOutput, error)
}
var _ DescribeJobsAPIClient = (*Client)(nil)
// DescribeJobsPaginatorOptions is the paginator options for DescribeJobs
type DescribeJobsPaginatorOptions struct {
// Request to describe job log items by max results.
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
}
// DescribeJobsPaginator is a paginator for DescribeJobs
type DescribeJobsPaginator struct {
options DescribeJobsPaginatorOptions
client DescribeJobsAPIClient
params *DescribeJobsInput
nextToken *string
firstPage bool
}
// NewDescribeJobsPaginator returns a new DescribeJobsPaginator
func NewDescribeJobsPaginator(client DescribeJobsAPIClient, params *DescribeJobsInput, optFns ...func(*DescribeJobsPaginatorOptions)) *DescribeJobsPaginator {
if params == nil {
params = &DescribeJobsInput{}
}
options := DescribeJobsPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeJobsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeJobsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeJobs page.
func (p *DescribeJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeJobsOutput, 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.DescribeJobs(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_opDescribeJobs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "DescribeJobs",
}
}
| 220 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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/mgn/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all Launch Configuration Templates, filtered by Launch Configuration
// Template IDs
func (c *Client) DescribeLaunchConfigurationTemplates(ctx context.Context, params *DescribeLaunchConfigurationTemplatesInput, optFns ...func(*Options)) (*DescribeLaunchConfigurationTemplatesOutput, error) {
if params == nil {
params = &DescribeLaunchConfigurationTemplatesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeLaunchConfigurationTemplates", params, optFns, c.addOperationDescribeLaunchConfigurationTemplatesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeLaunchConfigurationTemplatesOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeLaunchConfigurationTemplatesInput struct {
// Request to filter Launch Configuration Templates list by Launch Configuration
// Template ID.
LaunchConfigurationTemplateIDs []string
// Maximum results to be returned in DescribeLaunchConfigurationTemplates.
MaxResults int32
// Next pagination token returned from DescribeLaunchConfigurationTemplates.
NextToken *string
noSmithyDocumentSerde
}
type DescribeLaunchConfigurationTemplatesOutput struct {
// List of items returned by DescribeLaunchConfigurationTemplates.
Items []types.LaunchConfigurationTemplate
// Next pagination token returned from DescribeLaunchConfigurationTemplates.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeLaunchConfigurationTemplatesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeLaunchConfigurationTemplates{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeLaunchConfigurationTemplates{}, 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_opDescribeLaunchConfigurationTemplates(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
}
// DescribeLaunchConfigurationTemplatesAPIClient is a client that implements the
// DescribeLaunchConfigurationTemplates operation.
type DescribeLaunchConfigurationTemplatesAPIClient interface {
DescribeLaunchConfigurationTemplates(context.Context, *DescribeLaunchConfigurationTemplatesInput, ...func(*Options)) (*DescribeLaunchConfigurationTemplatesOutput, error)
}
var _ DescribeLaunchConfigurationTemplatesAPIClient = (*Client)(nil)
// DescribeLaunchConfigurationTemplatesPaginatorOptions is the paginator options
// for DescribeLaunchConfigurationTemplates
type DescribeLaunchConfigurationTemplatesPaginatorOptions struct {
// Maximum results to be returned in DescribeLaunchConfigurationTemplates.
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
}
// DescribeLaunchConfigurationTemplatesPaginator is a paginator for
// DescribeLaunchConfigurationTemplates
type DescribeLaunchConfigurationTemplatesPaginator struct {
options DescribeLaunchConfigurationTemplatesPaginatorOptions
client DescribeLaunchConfigurationTemplatesAPIClient
params *DescribeLaunchConfigurationTemplatesInput
nextToken *string
firstPage bool
}
// NewDescribeLaunchConfigurationTemplatesPaginator returns a new
// DescribeLaunchConfigurationTemplatesPaginator
func NewDescribeLaunchConfigurationTemplatesPaginator(client DescribeLaunchConfigurationTemplatesAPIClient, params *DescribeLaunchConfigurationTemplatesInput, optFns ...func(*DescribeLaunchConfigurationTemplatesPaginatorOptions)) *DescribeLaunchConfigurationTemplatesPaginator {
if params == nil {
params = &DescribeLaunchConfigurationTemplatesInput{}
}
options := DescribeLaunchConfigurationTemplatesPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeLaunchConfigurationTemplatesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeLaunchConfigurationTemplatesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeLaunchConfigurationTemplates page.
func (p *DescribeLaunchConfigurationTemplatesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeLaunchConfigurationTemplatesOutput, 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.DescribeLaunchConfigurationTemplates(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_opDescribeLaunchConfigurationTemplates(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "DescribeLaunchConfigurationTemplates",
}
}
| 221 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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/mgn/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all ReplicationConfigurationTemplates, filtered by Source Server IDs.
func (c *Client) DescribeReplicationConfigurationTemplates(ctx context.Context, params *DescribeReplicationConfigurationTemplatesInput, optFns ...func(*Options)) (*DescribeReplicationConfigurationTemplatesOutput, error) {
if params == nil {
params = &DescribeReplicationConfigurationTemplatesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeReplicationConfigurationTemplates", params, optFns, c.addOperationDescribeReplicationConfigurationTemplatesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeReplicationConfigurationTemplatesOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeReplicationConfigurationTemplatesInput struct {
// Request to describe Replication Configuration template by max results.
MaxResults int32
// Request to describe Replication Configuration template by next token.
NextToken *string
// Request to describe Replication Configuration template by template IDs.
ReplicationConfigurationTemplateIDs []string
noSmithyDocumentSerde
}
type DescribeReplicationConfigurationTemplatesOutput struct {
// Request to describe Replication Configuration template by items.
Items []types.ReplicationConfigurationTemplate
// Request to describe Replication Configuration template by next token.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeReplicationConfigurationTemplatesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeReplicationConfigurationTemplates{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeReplicationConfigurationTemplates{}, 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_opDescribeReplicationConfigurationTemplates(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
}
// DescribeReplicationConfigurationTemplatesAPIClient is a client that implements
// the DescribeReplicationConfigurationTemplates operation.
type DescribeReplicationConfigurationTemplatesAPIClient interface {
DescribeReplicationConfigurationTemplates(context.Context, *DescribeReplicationConfigurationTemplatesInput, ...func(*Options)) (*DescribeReplicationConfigurationTemplatesOutput, error)
}
var _ DescribeReplicationConfigurationTemplatesAPIClient = (*Client)(nil)
// DescribeReplicationConfigurationTemplatesPaginatorOptions is the paginator
// options for DescribeReplicationConfigurationTemplates
type DescribeReplicationConfigurationTemplatesPaginatorOptions struct {
// Request to describe Replication Configuration template by max results.
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
}
// DescribeReplicationConfigurationTemplatesPaginator is a paginator for
// DescribeReplicationConfigurationTemplates
type DescribeReplicationConfigurationTemplatesPaginator struct {
options DescribeReplicationConfigurationTemplatesPaginatorOptions
client DescribeReplicationConfigurationTemplatesAPIClient
params *DescribeReplicationConfigurationTemplatesInput
nextToken *string
firstPage bool
}
// NewDescribeReplicationConfigurationTemplatesPaginator returns a new
// DescribeReplicationConfigurationTemplatesPaginator
func NewDescribeReplicationConfigurationTemplatesPaginator(client DescribeReplicationConfigurationTemplatesAPIClient, params *DescribeReplicationConfigurationTemplatesInput, optFns ...func(*DescribeReplicationConfigurationTemplatesPaginatorOptions)) *DescribeReplicationConfigurationTemplatesPaginator {
if params == nil {
params = &DescribeReplicationConfigurationTemplatesInput{}
}
options := DescribeReplicationConfigurationTemplatesPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeReplicationConfigurationTemplatesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeReplicationConfigurationTemplatesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeReplicationConfigurationTemplates page.
func (p *DescribeReplicationConfigurationTemplatesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeReplicationConfigurationTemplatesOutput, 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.DescribeReplicationConfigurationTemplates(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_opDescribeReplicationConfigurationTemplates(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "DescribeReplicationConfigurationTemplates",
}
}
| 219 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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/mgn/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves all SourceServers or multiple SourceServers by ID.
func (c *Client) DescribeSourceServers(ctx context.Context, params *DescribeSourceServersInput, optFns ...func(*Options)) (*DescribeSourceServersOutput, error) {
if params == nil {
params = &DescribeSourceServersInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeSourceServers", params, optFns, c.addOperationDescribeSourceServersMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeSourceServersOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeSourceServersInput struct {
// Request to filter Source Servers list.
Filters *types.DescribeSourceServersRequestFilters
// Request to filter Source Servers list by maximum results.
MaxResults int32
// Request to filter Source Servers list by next token.
NextToken *string
noSmithyDocumentSerde
}
type DescribeSourceServersOutput struct {
// Request to filter Source Servers list by item.
Items []types.SourceServer
// Request to filter Source Servers next token.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeSourceServersMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeSourceServers{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeSourceServers{}, 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_opDescribeSourceServers(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
}
// DescribeSourceServersAPIClient is a client that implements the
// DescribeSourceServers operation.
type DescribeSourceServersAPIClient interface {
DescribeSourceServers(context.Context, *DescribeSourceServersInput, ...func(*Options)) (*DescribeSourceServersOutput, error)
}
var _ DescribeSourceServersAPIClient = (*Client)(nil)
// DescribeSourceServersPaginatorOptions is the paginator options for
// DescribeSourceServers
type DescribeSourceServersPaginatorOptions struct {
// Request to filter Source Servers list by maximum results.
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
}
// DescribeSourceServersPaginator is a paginator for DescribeSourceServers
type DescribeSourceServersPaginator struct {
options DescribeSourceServersPaginatorOptions
client DescribeSourceServersAPIClient
params *DescribeSourceServersInput
nextToken *string
firstPage bool
}
// NewDescribeSourceServersPaginator returns a new DescribeSourceServersPaginator
func NewDescribeSourceServersPaginator(client DescribeSourceServersAPIClient, params *DescribeSourceServersInput, optFns ...func(*DescribeSourceServersPaginatorOptions)) *DescribeSourceServersPaginator {
if params == nil {
params = &DescribeSourceServersInput{}
}
options := DescribeSourceServersPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeSourceServersPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeSourceServersPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeSourceServers page.
func (p *DescribeSourceServersPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeSourceServersOutput, 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.DescribeSourceServers(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_opDescribeSourceServers(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "DescribeSourceServers",
}
}
| 217 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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/mgn/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of the installed vCenter clients.
func (c *Client) DescribeVcenterClients(ctx context.Context, params *DescribeVcenterClientsInput, optFns ...func(*Options)) (*DescribeVcenterClientsOutput, error) {
if params == nil {
params = &DescribeVcenterClientsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeVcenterClients", params, optFns, c.addOperationDescribeVcenterClientsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeVcenterClientsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeVcenterClientsInput struct {
// Maximum results to be returned in DescribeVcenterClients.
MaxResults int32
// Next pagination token to be provided for DescribeVcenterClients.
NextToken *string
noSmithyDocumentSerde
}
type DescribeVcenterClientsOutput struct {
// List of items returned by DescribeVcenterClients.
Items []types.VcenterClient
// Next pagination token returned from DescribeVcenterClients.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeVcenterClientsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDescribeVcenterClients{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDescribeVcenterClients{}, 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_opDescribeVcenterClients(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
}
// DescribeVcenterClientsAPIClient is a client that implements the
// DescribeVcenterClients operation.
type DescribeVcenterClientsAPIClient interface {
DescribeVcenterClients(context.Context, *DescribeVcenterClientsInput, ...func(*Options)) (*DescribeVcenterClientsOutput, error)
}
var _ DescribeVcenterClientsAPIClient = (*Client)(nil)
// DescribeVcenterClientsPaginatorOptions is the paginator options for
// DescribeVcenterClients
type DescribeVcenterClientsPaginatorOptions struct {
// Maximum results to be returned in DescribeVcenterClients.
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
}
// DescribeVcenterClientsPaginator is a paginator for DescribeVcenterClients
type DescribeVcenterClientsPaginator struct {
options DescribeVcenterClientsPaginatorOptions
client DescribeVcenterClientsAPIClient
params *DescribeVcenterClientsInput
nextToken *string
firstPage bool
}
// NewDescribeVcenterClientsPaginator returns a new DescribeVcenterClientsPaginator
func NewDescribeVcenterClientsPaginator(client DescribeVcenterClientsAPIClient, params *DescribeVcenterClientsInput, optFns ...func(*DescribeVcenterClientsPaginatorOptions)) *DescribeVcenterClientsPaginator {
if params == nil {
params = &DescribeVcenterClientsInput{}
}
options := DescribeVcenterClientsPaginatorOptions{}
if params.MaxResults != 0 {
options.Limit = params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeVcenterClientsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeVcenterClientsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeVcenterClients page.
func (p *DescribeVcenterClientsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeVcenterClientsOutput, 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.DescribeVcenterClients(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_opDescribeVcenterClients(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "DescribeVcenterClients",
}
}
| 214 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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"
)
// Disassociate applications from wave.
func (c *Client) DisassociateApplications(ctx context.Context, params *DisassociateApplicationsInput, optFns ...func(*Options)) (*DisassociateApplicationsOutput, error) {
if params == nil {
params = &DisassociateApplicationsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DisassociateApplications", params, optFns, c.addOperationDisassociateApplicationsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DisassociateApplicationsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DisassociateApplicationsInput struct {
// Application IDs list.
//
// This member is required.
ApplicationIDs []string
// Wave ID.
//
// This member is required.
WaveID *string
noSmithyDocumentSerde
}
type DisassociateApplicationsOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDisassociateApplicationsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDisassociateApplications{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDisassociateApplications{}, 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 = addOpDisassociateApplicationsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDisassociateApplications(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_opDisassociateApplications(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "DisassociateApplications",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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"
)
// Disassociate source servers from application.
func (c *Client) DisassociateSourceServers(ctx context.Context, params *DisassociateSourceServersInput, optFns ...func(*Options)) (*DisassociateSourceServersOutput, error) {
if params == nil {
params = &DisassociateSourceServersInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DisassociateSourceServers", params, optFns, c.addOperationDisassociateSourceServersMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DisassociateSourceServersOutput)
out.ResultMetadata = metadata
return out, nil
}
type DisassociateSourceServersInput struct {
// Application ID.
//
// This member is required.
ApplicationID *string
// Source server IDs list.
//
// This member is required.
SourceServerIDs []string
noSmithyDocumentSerde
}
type DisassociateSourceServersOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDisassociateSourceServersMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDisassociateSourceServers{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDisassociateSourceServers{}, 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 = addOpDisassociateSourceServersValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDisassociateSourceServers(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_opDisassociateSourceServers(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "DisassociateSourceServers",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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/mgn/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Disconnects specific Source Servers from Application Migration Service. Data
// replication is stopped immediately. All AWS resources created by Application
// Migration Service for enabling the replication of these source servers will be
// terminated / deleted within 90 minutes. Launched Test or Cutover instances will
// NOT be terminated. If the agent on the source server has not been prevented from
// communicating with the Application Migration Service service, then it will
// receive a command to uninstall itself (within approximately 10 minutes). The
// following properties of the SourceServer will be changed immediately:
// dataReplicationInfo.dataReplicationState will be set to DISCONNECTED; The
// totalStorageBytes property for each of dataReplicationInfo.replicatedDisks will
// be set to zero; dataReplicationInfo.lagDuration and
// dataReplicationInfo.lagDuration will be nullified.
func (c *Client) DisconnectFromService(ctx context.Context, params *DisconnectFromServiceInput, optFns ...func(*Options)) (*DisconnectFromServiceOutput, error) {
if params == nil {
params = &DisconnectFromServiceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DisconnectFromService", params, optFns, c.addOperationDisconnectFromServiceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DisconnectFromServiceOutput)
out.ResultMetadata = metadata
return out, nil
}
type DisconnectFromServiceInput struct {
// Request to disconnect Source Server from service by Server ID.
//
// This member is required.
SourceServerID *string
noSmithyDocumentSerde
}
type DisconnectFromServiceOutput struct {
// Source server application ID.
ApplicationID *string
// Source server ARN.
Arn *string
// Source server data replication info.
DataReplicationInfo *types.DataReplicationInfo
// Source server fqdn for action framework.
FqdnForActionFramework *string
// Source server archived status.
IsArchived *bool
// Source server launched instance.
LaunchedInstance *types.LaunchedInstance
// Source server lifecycle state.
LifeCycle *types.LifeCycle
// Source server replication type.
ReplicationType types.ReplicationType
// Source server properties.
SourceProperties *types.SourceProperties
// Source server ID.
SourceServerID *string
// Source server Tags.
Tags map[string]string
// Source server user provided ID.
UserProvidedID *string
// Source server vCenter client id.
VcenterClientID *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDisconnectFromServiceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDisconnectFromService{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDisconnectFromService{}, 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 = addOpDisconnectFromServiceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDisconnectFromService(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_opDisconnectFromService(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "DisconnectFromService",
}
}
| 172 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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/mgn/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Finalizes the cutover immediately for specific Source Servers. All AWS
// resources created by Application Migration Service for enabling the replication
// of these source servers will be terminated / deleted within 90 minutes. Launched
// Test or Cutover instances will NOT be terminated. The AWS Replication Agent will
// receive a command to uninstall itself (within 10 minutes). The following
// properties of the SourceServer will be changed immediately:
// dataReplicationInfo.dataReplicationState will be changed to DISCONNECTED; The
// SourceServer.lifeCycle.state will be changed to CUTOVER; The totalStorageBytes
// property fo each of dataReplicationInfo.replicatedDisks will be set to zero;
// dataReplicationInfo.lagDuration and dataReplicationInfo.lagDuration will be
// nullified.
func (c *Client) FinalizeCutover(ctx context.Context, params *FinalizeCutoverInput, optFns ...func(*Options)) (*FinalizeCutoverOutput, error) {
if params == nil {
params = &FinalizeCutoverInput{}
}
result, metadata, err := c.invokeOperation(ctx, "FinalizeCutover", params, optFns, c.addOperationFinalizeCutoverMiddlewares)
if err != nil {
return nil, err
}
out := result.(*FinalizeCutoverOutput)
out.ResultMetadata = metadata
return out, nil
}
type FinalizeCutoverInput struct {
// Request to finalize Cutover by Source Server ID.
//
// This member is required.
SourceServerID *string
noSmithyDocumentSerde
}
type FinalizeCutoverOutput struct {
// Source server application ID.
ApplicationID *string
// Source server ARN.
Arn *string
// Source server data replication info.
DataReplicationInfo *types.DataReplicationInfo
// Source server fqdn for action framework.
FqdnForActionFramework *string
// Source server archived status.
IsArchived *bool
// Source server launched instance.
LaunchedInstance *types.LaunchedInstance
// Source server lifecycle state.
LifeCycle *types.LifeCycle
// Source server replication type.
ReplicationType types.ReplicationType
// Source server properties.
SourceProperties *types.SourceProperties
// Source server ID.
SourceServerID *string
// Source server Tags.
Tags map[string]string
// Source server user provided ID.
UserProvidedID *string
// Source server vCenter client id.
VcenterClientID *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationFinalizeCutoverMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpFinalizeCutover{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpFinalizeCutover{}, 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 = addOpFinalizeCutoverValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opFinalizeCutover(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_opFinalizeCutover(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "FinalizeCutover",
}
}
| 171 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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/mgn/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all LaunchConfigurations available, filtered by Source Server IDs.
func (c *Client) GetLaunchConfiguration(ctx context.Context, params *GetLaunchConfigurationInput, optFns ...func(*Options)) (*GetLaunchConfigurationOutput, error) {
if params == nil {
params = &GetLaunchConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetLaunchConfiguration", params, optFns, c.addOperationGetLaunchConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetLaunchConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetLaunchConfigurationInput struct {
// Request to get Launch Configuration information by Source Server ID.
//
// This member is required.
SourceServerID *string
noSmithyDocumentSerde
}
type GetLaunchConfigurationOutput struct {
// Launch configuration boot mode.
BootMode types.BootMode
// Copy Private IP during Launch Configuration.
CopyPrivateIp *bool
// Copy Tags during Launch Configuration.
CopyTags *bool
// Launch configuration EC2 Launch template ID.
Ec2LaunchTemplateID *string
// Enable map auto tagging.
EnableMapAutoTagging *bool
// Launch disposition for launch configuration.
LaunchDisposition types.LaunchDisposition
// Launch configuration OS licensing.
Licensing *types.Licensing
// Map auto tagging MPE ID.
MapAutoTaggingMpeID *string
// Launch configuration name.
Name *string
// Post Launch Actions to executed on the Test or Cutover instance.
PostLaunchActions *types.PostLaunchActions
// Launch configuration Source Server ID.
SourceServerID *string
// Launch configuration Target instance type right sizing method.
TargetInstanceTypeRightSizingMethod types.TargetInstanceTypeRightSizingMethod
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetLaunchConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetLaunchConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetLaunchConfiguration{}, 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 = addOpGetLaunchConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetLaunchConfiguration(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_opGetLaunchConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "GetLaunchConfiguration",
}
}
| 158 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package mgn
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/mgn/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists all ReplicationConfigurations, filtered by Source Server ID.
func (c *Client) GetReplicationConfiguration(ctx context.Context, params *GetReplicationConfigurationInput, optFns ...func(*Options)) (*GetReplicationConfigurationOutput, error) {
if params == nil {
params = &GetReplicationConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetReplicationConfiguration", params, optFns, c.addOperationGetReplicationConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetReplicationConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetReplicationConfigurationInput struct {
// Request to get Replication Configuration by Source Server ID.
//
// This member is required.
SourceServerID *string
noSmithyDocumentSerde
}
type GetReplicationConfigurationOutput struct {
// Replication Configuration associate default Application Migration Service
// Security Group.
AssociateDefaultSecurityGroup *bool
// Replication Configuration set bandwidth throttling.
BandwidthThrottling int64
// Replication Configuration create Public IP.
CreatePublicIP *bool
// Replication Configuration data plane routing.
DataPlaneRouting types.ReplicationConfigurationDataPlaneRouting
// Replication Configuration use default large Staging Disks.
DefaultLargeStagingDiskType types.ReplicationConfigurationDefaultLargeStagingDiskType
// Replication Configuration EBS encryption.
EbsEncryption types.ReplicationConfigurationEbsEncryption
// Replication Configuration EBS encryption key ARN.
EbsEncryptionKeyArn *string
// Replication Configuration name.
Name *string
// Replication Configuration replicated disks.
ReplicatedDisks []types.ReplicationConfigurationReplicatedDisk
// Replication Configuration Replication Server instance type.
ReplicationServerInstanceType *string
// Replication Configuration Replication Server Security Group IDs.
ReplicationServersSecurityGroupsIDs []string
// Replication Configuration Source Server ID.
SourceServerID *string
// Replication Configuration Staging Area subnet ID.
StagingAreaSubnetId *string
// Replication Configuration Staging Area tags.
StagingAreaTags map[string]string
// Replication Configuration use Dedicated Replication Server.
UseDedicatedReplicationServer *bool
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetReplicationConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetReplicationConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetReplicationConfiguration{}, 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 = addOpGetReplicationConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetReplicationConfiguration(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_opGetReplicationConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "mgn",
OperationName: "GetReplicationConfiguration",
}
}
| 168 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.