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 inspector2
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"
)
// Disables the Amazon Inspector delegated administrator for your organization.
func (c *Client) DisableDelegatedAdminAccount(ctx context.Context, params *DisableDelegatedAdminAccountInput, optFns ...func(*Options)) (*DisableDelegatedAdminAccountOutput, error) {
if params == nil {
params = &DisableDelegatedAdminAccountInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DisableDelegatedAdminAccount", params, optFns, c.addOperationDisableDelegatedAdminAccountMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DisableDelegatedAdminAccountOutput)
out.ResultMetadata = metadata
return out, nil
}
type DisableDelegatedAdminAccountInput struct {
// The Amazon Web Services account ID of the current Amazon Inspector delegated
// administrator.
//
// This member is required.
DelegatedAdminAccountId *string
noSmithyDocumentSerde
}
type DisableDelegatedAdminAccountOutput struct {
// The Amazon Web Services account ID of the successfully disabled delegated
// administrator.
//
// This member is required.
DelegatedAdminAccountId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDisableDelegatedAdminAccountMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDisableDelegatedAdminAccount{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDisableDelegatedAdminAccount{}, 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 = addOpDisableDelegatedAdminAccountValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDisableDelegatedAdminAccount(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_opDisableDelegatedAdminAccount(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "DisableDelegatedAdminAccount",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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"
)
// Disassociates a member account from an Amazon Inspector delegated administrator.
func (c *Client) DisassociateMember(ctx context.Context, params *DisassociateMemberInput, optFns ...func(*Options)) (*DisassociateMemberOutput, error) {
if params == nil {
params = &DisassociateMemberInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DisassociateMember", params, optFns, c.addOperationDisassociateMemberMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DisassociateMemberOutput)
out.ResultMetadata = metadata
return out, nil
}
type DisassociateMemberInput struct {
// The Amazon Web Services account ID of the member account to disassociate.
//
// This member is required.
AccountId *string
noSmithyDocumentSerde
}
type DisassociateMemberOutput struct {
// The Amazon Web Services account ID of the successfully disassociated member.
//
// This member is required.
AccountId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDisassociateMemberMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpDisassociateMember{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpDisassociateMember{}, 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 = addOpDisassociateMemberValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDisassociateMember(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_opDisassociateMember(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "DisassociateMember",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Enables Amazon Inspector scans for one or more Amazon Web Services accounts.
func (c *Client) Enable(ctx context.Context, params *EnableInput, optFns ...func(*Options)) (*EnableOutput, error) {
if params == nil {
params = &EnableInput{}
}
result, metadata, err := c.invokeOperation(ctx, "Enable", params, optFns, c.addOperationEnableMiddlewares)
if err != nil {
return nil, err
}
out := result.(*EnableOutput)
out.ResultMetadata = metadata
return out, nil
}
type EnableInput struct {
// The resource scan types you want to enable.
//
// This member is required.
ResourceTypes []types.ResourceScanType
// A list of account IDs you want to enable Amazon Inspector scans for.
AccountIds []string
// The idempotency token for the request.
ClientToken *string
noSmithyDocumentSerde
}
type EnableOutput struct {
// Information on the accounts that have had Amazon Inspector scans successfully
// enabled. Details are provided for each account.
//
// This member is required.
Accounts []types.Account
// Information on any accounts for which Amazon Inspector scans could not be
// enabled. Details are provided for each account.
FailedAccounts []types.FailedAccount
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationEnableMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpEnable{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpEnable{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addIdempotencyToken_opEnableMiddleware(stack, options); err != nil {
return err
}
if err = addOpEnableValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opEnable(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type idempotencyToken_initializeOpEnable struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpEnable) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpEnable) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*EnableInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *EnableInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opEnableMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpEnable{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opEnable(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "Enable",
}
}
| 175 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Enables the Amazon Inspector delegated administrator for your Organizations
// organization.
func (c *Client) EnableDelegatedAdminAccount(ctx context.Context, params *EnableDelegatedAdminAccountInput, optFns ...func(*Options)) (*EnableDelegatedAdminAccountOutput, error) {
if params == nil {
params = &EnableDelegatedAdminAccountInput{}
}
result, metadata, err := c.invokeOperation(ctx, "EnableDelegatedAdminAccount", params, optFns, c.addOperationEnableDelegatedAdminAccountMiddlewares)
if err != nil {
return nil, err
}
out := result.(*EnableDelegatedAdminAccountOutput)
out.ResultMetadata = metadata
return out, nil
}
type EnableDelegatedAdminAccountInput struct {
// The Amazon Web Services account ID of the Amazon Inspector delegated
// administrator.
//
// This member is required.
DelegatedAdminAccountId *string
// The idempotency token for the request.
ClientToken *string
noSmithyDocumentSerde
}
type EnableDelegatedAdminAccountOutput struct {
// The Amazon Web Services account ID of the successfully Amazon Inspector
// delegated administrator.
//
// This member is required.
DelegatedAdminAccountId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationEnableDelegatedAdminAccountMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpEnableDelegatedAdminAccount{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpEnableDelegatedAdminAccount{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addIdempotencyToken_opEnableDelegatedAdminAccountMiddleware(stack, options); err != nil {
return err
}
if err = addOpEnableDelegatedAdminAccountValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opEnableDelegatedAdminAccount(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
type idempotencyToken_initializeOpEnableDelegatedAdminAccount struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpEnableDelegatedAdminAccount) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpEnableDelegatedAdminAccount) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*EnableDelegatedAdminAccountInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *EnableDelegatedAdminAccountInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opEnableDelegatedAdminAccountMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpEnableDelegatedAdminAccount{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opEnableDelegatedAdminAccount(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "EnableDelegatedAdminAccount",
}
}
| 169 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves setting configurations for Inspector scans.
func (c *Client) GetConfiguration(ctx context.Context, params *GetConfigurationInput, optFns ...func(*Options)) (*GetConfigurationOutput, error) {
if params == nil {
params = &GetConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetConfiguration", params, optFns, c.addOperationGetConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetConfigurationInput struct {
noSmithyDocumentSerde
}
type GetConfigurationOutput struct {
// Specifies how the ECR automated re-scan duration is currently configured for
// your environment.
EcrConfiguration *types.EcrConfigurationState
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetConfiguration{}, 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_opGetConfiguration(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_opGetConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "GetConfiguration",
}
}
| 117 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves information about the Amazon Inspector delegated administrator for
// your organization.
func (c *Client) GetDelegatedAdminAccount(ctx context.Context, params *GetDelegatedAdminAccountInput, optFns ...func(*Options)) (*GetDelegatedAdminAccountOutput, error) {
if params == nil {
params = &GetDelegatedAdminAccountInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetDelegatedAdminAccount", params, optFns, c.addOperationGetDelegatedAdminAccountMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetDelegatedAdminAccountOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetDelegatedAdminAccountInput struct {
noSmithyDocumentSerde
}
type GetDelegatedAdminAccountOutput struct {
// The Amazon Web Services account ID of the Amazon Inspector delegated
// administrator.
DelegatedAdmin *types.DelegatedAdmin
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetDelegatedAdminAccountMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetDelegatedAdminAccount{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetDelegatedAdminAccount{}, 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_opGetDelegatedAdminAccount(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_opGetDelegatedAdminAccount(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "GetDelegatedAdminAccount",
}
}
| 118 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves the activation status of Amazon Inspector deep inspection and custom
// paths associated with your account.
func (c *Client) GetEc2DeepInspectionConfiguration(ctx context.Context, params *GetEc2DeepInspectionConfigurationInput, optFns ...func(*Options)) (*GetEc2DeepInspectionConfigurationOutput, error) {
if params == nil {
params = &GetEc2DeepInspectionConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetEc2DeepInspectionConfiguration", params, optFns, c.addOperationGetEc2DeepInspectionConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetEc2DeepInspectionConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetEc2DeepInspectionConfigurationInput struct {
noSmithyDocumentSerde
}
type GetEc2DeepInspectionConfigurationOutput struct {
// An error message explaining why Amazon Inspector deep inspection configurations
// could not be retrieved for your account.
ErrorMessage *string
// The Amazon Inspector deep inspection custom paths for your organization.
OrgPackagePaths []string
// The Amazon Inspector deep inspection custom paths for your account.
PackagePaths []string
// The activation status of Amazon Inspector deep inspection in your account.
Status types.Ec2DeepInspectionStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetEc2DeepInspectionConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetEc2DeepInspectionConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetEc2DeepInspectionConfiguration{}, 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_opGetEc2DeepInspectionConfiguration(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_opGetEc2DeepInspectionConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "GetEc2DeepInspectionConfiguration",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets an encryption key.
func (c *Client) GetEncryptionKey(ctx context.Context, params *GetEncryptionKeyInput, optFns ...func(*Options)) (*GetEncryptionKeyOutput, error) {
if params == nil {
params = &GetEncryptionKeyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetEncryptionKey", params, optFns, c.addOperationGetEncryptionKeyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetEncryptionKeyOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetEncryptionKeyInput struct {
// The resource type the key encrypts.
//
// This member is required.
ResourceType types.ResourceType
// The scan type the key encrypts.
//
// This member is required.
ScanType types.ScanType
noSmithyDocumentSerde
}
type GetEncryptionKeyOutput struct {
// A kms key ID.
//
// This member is required.
KmsKeyId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetEncryptionKeyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetEncryptionKey{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetEncryptionKey{}, 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 = addOpGetEncryptionKeyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetEncryptionKey(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_opGetEncryptionKey(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "GetEncryptionKey",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets the status of a findings report.
func (c *Client) GetFindingsReportStatus(ctx context.Context, params *GetFindingsReportStatusInput, optFns ...func(*Options)) (*GetFindingsReportStatusOutput, error) {
if params == nil {
params = &GetFindingsReportStatusInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetFindingsReportStatus", params, optFns, c.addOperationGetFindingsReportStatusMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetFindingsReportStatusOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetFindingsReportStatusInput struct {
// The ID of the report to retrieve the status of.
ReportId *string
noSmithyDocumentSerde
}
type GetFindingsReportStatusOutput struct {
// The destination of the report.
Destination *types.Destination
// The error code of the report.
ErrorCode types.ReportingErrorCode
// The error message of the report.
ErrorMessage *string
// The filter criteria associated with the report.
FilterCriteria *types.FilterCriteria
// The ID of the report.
ReportId *string
// The status of the report.
Status types.ExternalReportStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetFindingsReportStatusMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetFindingsReportStatus{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetFindingsReportStatus{}, 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_opGetFindingsReportStatus(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_opGetFindingsReportStatus(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "GetFindingsReportStatus",
}
}
| 135 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets member information for your organization.
func (c *Client) GetMember(ctx context.Context, params *GetMemberInput, optFns ...func(*Options)) (*GetMemberOutput, error) {
if params == nil {
params = &GetMemberInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetMember", params, optFns, c.addOperationGetMemberMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetMemberOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetMemberInput struct {
// The Amazon Web Services account ID of the member account to retrieve
// information on.
//
// This member is required.
AccountId *string
noSmithyDocumentSerde
}
type GetMemberOutput struct {
// Details of the retrieved member account.
Member *types.Member
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetMemberMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetMember{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetMember{}, 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 = addOpGetMemberValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetMember(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_opGetMember(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "GetMember",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets details of a software bill of materials (SBOM) report.
func (c *Client) GetSbomExport(ctx context.Context, params *GetSbomExportInput, optFns ...func(*Options)) (*GetSbomExportOutput, error) {
if params == nil {
params = &GetSbomExportInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetSbomExport", params, optFns, c.addOperationGetSbomExportMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetSbomExportOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetSbomExportInput struct {
// The report ID of the SBOM export to get details for.
//
// This member is required.
ReportId *string
noSmithyDocumentSerde
}
type GetSbomExportOutput struct {
// An error code.
ErrorCode types.ReportingErrorCode
// An error message.
ErrorMessage *string
// Contains details about the resource filter criteria used for the software bill
// of materials (SBOM) report.
FilterCriteria *types.ResourceFilterCriteria
// The format of the software bill of materials (SBOM) report.
Format types.SbomReportFormat
// The report ID of the software bill of materials (SBOM) report.
ReportId *string
// Contains details of the Amazon S3 bucket and KMS key used to export findings.
S3Destination *types.Destination
// The status of the software bill of materials (SBOM) report.
Status types.ExternalReportStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetSbomExportMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpGetSbomExport{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpGetSbomExport{}, 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 = addOpGetSbomExportValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetSbomExport(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_opGetSbomExport(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "GetSbomExport",
}
}
| 144 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the permissions an account has to configure Amazon Inspector.
func (c *Client) ListAccountPermissions(ctx context.Context, params *ListAccountPermissionsInput, optFns ...func(*Options)) (*ListAccountPermissionsOutput, error) {
if params == nil {
params = &ListAccountPermissionsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListAccountPermissions", params, optFns, c.addOperationListAccountPermissionsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListAccountPermissionsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListAccountPermissionsInput struct {
// The maximum number of results to return in the response.
MaxResults *int32
// A token to use for paginating results that are returned in the response. Set
// the value of this parameter to null for the first request to a list action. For
// subsequent calls, use the NextToken value returned from the previous request to
// continue listing results after the first page.
NextToken *string
// The service scan type to check permissions for.
Service types.Service
noSmithyDocumentSerde
}
type ListAccountPermissionsOutput struct {
// Contains details on the permissions an account has to configure Amazon
// Inspector.
//
// This member is required.
Permissions []types.Permission
// A token to use for paginating results that are returned in the response. Set
// the value of this parameter to null for the first request to a list action. For
// subsequent calls, use the NextToken value returned from the previous request to
// continue listing results after the first page.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListAccountPermissionsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListAccountPermissions{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListAccountPermissions{}, 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_opListAccountPermissions(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
}
// ListAccountPermissionsAPIClient is a client that implements the
// ListAccountPermissions operation.
type ListAccountPermissionsAPIClient interface {
ListAccountPermissions(context.Context, *ListAccountPermissionsInput, ...func(*Options)) (*ListAccountPermissionsOutput, error)
}
var _ ListAccountPermissionsAPIClient = (*Client)(nil)
// ListAccountPermissionsPaginatorOptions is the paginator options for
// ListAccountPermissions
type ListAccountPermissionsPaginatorOptions struct {
// The maximum number of results to return in the response.
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
}
// ListAccountPermissionsPaginator is a paginator for ListAccountPermissions
type ListAccountPermissionsPaginator struct {
options ListAccountPermissionsPaginatorOptions
client ListAccountPermissionsAPIClient
params *ListAccountPermissionsInput
nextToken *string
firstPage bool
}
// NewListAccountPermissionsPaginator returns a new ListAccountPermissionsPaginator
func NewListAccountPermissionsPaginator(client ListAccountPermissionsAPIClient, params *ListAccountPermissionsInput, optFns ...func(*ListAccountPermissionsPaginatorOptions)) *ListAccountPermissionsPaginator {
if params == nil {
params = &ListAccountPermissionsInput{}
}
options := ListAccountPermissionsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListAccountPermissionsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListAccountPermissionsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListAccountPermissions page.
func (p *ListAccountPermissionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListAccountPermissionsOutput, 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.ListAccountPermissions(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_opListAccountPermissions(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "ListAccountPermissions",
}
}
| 230 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists coverage details for you environment.
func (c *Client) ListCoverage(ctx context.Context, params *ListCoverageInput, optFns ...func(*Options)) (*ListCoverageOutput, error) {
if params == nil {
params = &ListCoverageInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListCoverage", params, optFns, c.addOperationListCoverageMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListCoverageOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListCoverageInput struct {
// An object that contains details on the filters to apply to the coverage data
// for your environment.
FilterCriteria *types.CoverageFilterCriteria
// The maximum number of results to return in the response.
MaxResults *int32
// A token to use for paginating results that are returned in the response. Set
// the value of this parameter to null for the first request to a list action. For
// subsequent calls, use the NextToken value returned from the previous request to
// continue listing results after the first page.
NextToken *string
noSmithyDocumentSerde
}
type ListCoverageOutput struct {
// An object that contains details on the covered resources in your environment.
CoveredResources []types.CoveredResource
// A token to use for paginating results that are returned in the response. Set
// the value of this parameter to null for the first request to a list action. For
// subsequent calls, use the NextToken value returned from the previous request to
// continue listing results after the first page.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListCoverageMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListCoverage{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListCoverage{}, 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 = addOpListCoverageValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListCoverage(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
}
// ListCoverageAPIClient is a client that implements the ListCoverage operation.
type ListCoverageAPIClient interface {
ListCoverage(context.Context, *ListCoverageInput, ...func(*Options)) (*ListCoverageOutput, error)
}
var _ ListCoverageAPIClient = (*Client)(nil)
// ListCoveragePaginatorOptions is the paginator options for ListCoverage
type ListCoveragePaginatorOptions struct {
// The maximum number of results to return in the response.
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
}
// ListCoveragePaginator is a paginator for ListCoverage
type ListCoveragePaginator struct {
options ListCoveragePaginatorOptions
client ListCoverageAPIClient
params *ListCoverageInput
nextToken *string
firstPage bool
}
// NewListCoveragePaginator returns a new ListCoveragePaginator
func NewListCoveragePaginator(client ListCoverageAPIClient, params *ListCoverageInput, optFns ...func(*ListCoveragePaginatorOptions)) *ListCoveragePaginator {
if params == nil {
params = &ListCoverageInput{}
}
options := ListCoveragePaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListCoveragePaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListCoveragePaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListCoverage page.
func (p *ListCoveragePaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListCoverageOutput, 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.ListCoverage(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_opListCoverage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "ListCoverage",
}
}
| 229 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists Amazon Inspector coverage statistics for your environment.
func (c *Client) ListCoverageStatistics(ctx context.Context, params *ListCoverageStatisticsInput, optFns ...func(*Options)) (*ListCoverageStatisticsOutput, error) {
if params == nil {
params = &ListCoverageStatisticsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListCoverageStatistics", params, optFns, c.addOperationListCoverageStatisticsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListCoverageStatisticsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListCoverageStatisticsInput struct {
// An object that contains details on the filters to apply to the coverage data
// for your environment.
FilterCriteria *types.CoverageFilterCriteria
// The value to group the results by.
GroupBy types.GroupKey
// A token to use for paginating results that are returned in the response. Set
// the value of this parameter to null for the first request to a list action. For
// subsequent calls, use the NextToken value returned from the previous request to
// continue listing results after the first page.
NextToken *string
noSmithyDocumentSerde
}
type ListCoverageStatisticsOutput struct {
// The total number for all groups.
//
// This member is required.
TotalCounts *int64
// An array with the number for each group.
CountsByGroup []types.Counts
// A token to use for paginating results that are returned in the response. Set
// the value of this parameter to null for the first request to a list action. For
// subsequent calls, use the NextToken value returned from the previous request to
// continue listing results after the first page.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListCoverageStatisticsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListCoverageStatistics{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListCoverageStatistics{}, 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 = addOpListCoverageStatisticsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListCoverageStatistics(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
}
// ListCoverageStatisticsAPIClient is a client that implements the
// ListCoverageStatistics operation.
type ListCoverageStatisticsAPIClient interface {
ListCoverageStatistics(context.Context, *ListCoverageStatisticsInput, ...func(*Options)) (*ListCoverageStatisticsOutput, error)
}
var _ ListCoverageStatisticsAPIClient = (*Client)(nil)
// ListCoverageStatisticsPaginatorOptions is the paginator options for
// ListCoverageStatistics
type ListCoverageStatisticsPaginatorOptions struct {
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListCoverageStatisticsPaginator is a paginator for ListCoverageStatistics
type ListCoverageStatisticsPaginator struct {
options ListCoverageStatisticsPaginatorOptions
client ListCoverageStatisticsAPIClient
params *ListCoverageStatisticsInput
nextToken *string
firstPage bool
}
// NewListCoverageStatisticsPaginator returns a new ListCoverageStatisticsPaginator
func NewListCoverageStatisticsPaginator(client ListCoverageStatisticsAPIClient, params *ListCoverageStatisticsInput, optFns ...func(*ListCoverageStatisticsPaginatorOptions)) *ListCoverageStatisticsPaginator {
if params == nil {
params = &ListCoverageStatisticsInput{}
}
options := ListCoverageStatisticsPaginatorOptions{}
for _, fn := range optFns {
fn(&options)
}
return &ListCoverageStatisticsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListCoverageStatisticsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListCoverageStatistics page.
func (p *ListCoverageStatisticsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListCoverageStatisticsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
result, err := p.client.ListCoverageStatistics(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_opListCoverageStatistics(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "ListCoverageStatistics",
}
}
| 224 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists information about the Amazon Inspector delegated administrator of your
// organization.
func (c *Client) ListDelegatedAdminAccounts(ctx context.Context, params *ListDelegatedAdminAccountsInput, optFns ...func(*Options)) (*ListDelegatedAdminAccountsOutput, error) {
if params == nil {
params = &ListDelegatedAdminAccountsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDelegatedAdminAccounts", params, optFns, c.addOperationListDelegatedAdminAccountsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDelegatedAdminAccountsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDelegatedAdminAccountsInput struct {
// The maximum number of results to return in the response.
MaxResults *int32
// A token to use for paginating results that are returned in the response. Set
// the value of this parameter to null for the first request to a list action. For
// subsequent calls, use the NextToken value returned from the previous request to
// continue listing results after the first page.
NextToken *string
noSmithyDocumentSerde
}
type ListDelegatedAdminAccountsOutput struct {
// Details of the Amazon Inspector delegated administrator of your organization.
DelegatedAdminAccounts []types.DelegatedAdminAccount
// A token to use for paginating results that are returned in the response. Set
// the value of this parameter to null for the first request to a list action. For
// subsequent calls, use the NextToken value returned from the previous request to
// continue listing results after the first page.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDelegatedAdminAccountsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListDelegatedAdminAccounts{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListDelegatedAdminAccounts{}, 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_opListDelegatedAdminAccounts(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
}
// ListDelegatedAdminAccountsAPIClient is a client that implements the
// ListDelegatedAdminAccounts operation.
type ListDelegatedAdminAccountsAPIClient interface {
ListDelegatedAdminAccounts(context.Context, *ListDelegatedAdminAccountsInput, ...func(*Options)) (*ListDelegatedAdminAccountsOutput, error)
}
var _ ListDelegatedAdminAccountsAPIClient = (*Client)(nil)
// ListDelegatedAdminAccountsPaginatorOptions is the paginator options for
// ListDelegatedAdminAccounts
type ListDelegatedAdminAccountsPaginatorOptions struct {
// The maximum number of results to return in the response.
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
}
// ListDelegatedAdminAccountsPaginator is a paginator for
// ListDelegatedAdminAccounts
type ListDelegatedAdminAccountsPaginator struct {
options ListDelegatedAdminAccountsPaginatorOptions
client ListDelegatedAdminAccountsAPIClient
params *ListDelegatedAdminAccountsInput
nextToken *string
firstPage bool
}
// NewListDelegatedAdminAccountsPaginator returns a new
// ListDelegatedAdminAccountsPaginator
func NewListDelegatedAdminAccountsPaginator(client ListDelegatedAdminAccountsAPIClient, params *ListDelegatedAdminAccountsInput, optFns ...func(*ListDelegatedAdminAccountsPaginatorOptions)) *ListDelegatedAdminAccountsPaginator {
if params == nil {
params = &ListDelegatedAdminAccountsInput{}
}
options := ListDelegatedAdminAccountsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListDelegatedAdminAccountsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListDelegatedAdminAccountsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListDelegatedAdminAccounts page.
func (p *ListDelegatedAdminAccountsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDelegatedAdminAccountsOutput, 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.ListDelegatedAdminAccounts(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_opListDelegatedAdminAccounts(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "ListDelegatedAdminAccounts",
}
}
| 227 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the filters associated with your account.
func (c *Client) ListFilters(ctx context.Context, params *ListFiltersInput, optFns ...func(*Options)) (*ListFiltersOutput, error) {
if params == nil {
params = &ListFiltersInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListFilters", params, optFns, c.addOperationListFiltersMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListFiltersOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListFiltersInput struct {
// The action the filter applies to matched findings.
Action types.FilterAction
// The Amazon resource number (ARN) of the filter.
Arns []string
// The maximum number of results to return in the response.
MaxResults *int32
// A token to use for paginating results that are returned in the response. Set
// the value of this parameter to null for the first request to a list action. For
// subsequent calls, use the NextToken value returned from the previous request to
// continue listing results after the first page.
NextToken *string
noSmithyDocumentSerde
}
type ListFiltersOutput struct {
// Contains details on the filters associated with your account.
//
// This member is required.
Filters []types.Filter
// A token to use for paginating results that are returned in the response. Set
// the value of this parameter to null for the first request to a list action. For
// subsequent calls, use the NextToken value returned from the previous request to
// continue listing results after the first page.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListFiltersMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListFilters{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListFilters{}, 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_opListFilters(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
}
// ListFiltersAPIClient is a client that implements the ListFilters operation.
type ListFiltersAPIClient interface {
ListFilters(context.Context, *ListFiltersInput, ...func(*Options)) (*ListFiltersOutput, error)
}
var _ ListFiltersAPIClient = (*Client)(nil)
// ListFiltersPaginatorOptions is the paginator options for ListFilters
type ListFiltersPaginatorOptions struct {
// The maximum number of results to return in the response.
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
}
// ListFiltersPaginator is a paginator for ListFilters
type ListFiltersPaginator struct {
options ListFiltersPaginatorOptions
client ListFiltersAPIClient
params *ListFiltersInput
nextToken *string
firstPage bool
}
// NewListFiltersPaginator returns a new ListFiltersPaginator
func NewListFiltersPaginator(client ListFiltersAPIClient, params *ListFiltersInput, optFns ...func(*ListFiltersPaginatorOptions)) *ListFiltersPaginator {
if params == nil {
params = &ListFiltersInput{}
}
options := ListFiltersPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListFiltersPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListFiltersPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListFilters page.
func (p *ListFiltersPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListFiltersOutput, 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.ListFilters(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_opListFilters(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "ListFilters",
}
}
| 230 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists aggregated finding data for your environment based on specific criteria.
func (c *Client) ListFindingAggregations(ctx context.Context, params *ListFindingAggregationsInput, optFns ...func(*Options)) (*ListFindingAggregationsOutput, error) {
if params == nil {
params = &ListFindingAggregationsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListFindingAggregations", params, optFns, c.addOperationListFindingAggregationsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListFindingAggregationsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListFindingAggregationsInput struct {
// The type of the aggregation request.
//
// This member is required.
AggregationType types.AggregationType
// The Amazon Web Services account IDs to retrieve finding aggregation data for.
AccountIds []types.StringFilter
// Details of the aggregation request that is used to filter your aggregation
// results.
AggregationRequest types.AggregationRequest
// The maximum number of results to return in the response.
MaxResults *int32
// A token to use for paginating results that are returned in the response. Set
// the value of this parameter to null for the first request to a list action. For
// subsequent calls, use the NextToken value returned from the previous request to
// continue listing results after the first page.
NextToken *string
noSmithyDocumentSerde
}
type ListFindingAggregationsOutput struct {
// The type of aggregation to perform.
//
// This member is required.
AggregationType types.AggregationType
// A token to use for paginating results that are returned in the response. Set
// the value of this parameter to null for the first request to a list action. For
// subsequent calls, use the NextToken value returned from the previous request to
// continue listing results after the first page.
NextToken *string
// Objects that contain the results of an aggregation operation.
Responses []types.AggregationResponse
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListFindingAggregationsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListFindingAggregations{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListFindingAggregations{}, 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 = addOpListFindingAggregationsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListFindingAggregations(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
}
// ListFindingAggregationsAPIClient is a client that implements the
// ListFindingAggregations operation.
type ListFindingAggregationsAPIClient interface {
ListFindingAggregations(context.Context, *ListFindingAggregationsInput, ...func(*Options)) (*ListFindingAggregationsOutput, error)
}
var _ ListFindingAggregationsAPIClient = (*Client)(nil)
// ListFindingAggregationsPaginatorOptions is the paginator options for
// ListFindingAggregations
type ListFindingAggregationsPaginatorOptions struct {
// The maximum number of results to return in the response.
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
}
// ListFindingAggregationsPaginator is a paginator for ListFindingAggregations
type ListFindingAggregationsPaginator struct {
options ListFindingAggregationsPaginatorOptions
client ListFindingAggregationsAPIClient
params *ListFindingAggregationsInput
nextToken *string
firstPage bool
}
// NewListFindingAggregationsPaginator returns a new
// ListFindingAggregationsPaginator
func NewListFindingAggregationsPaginator(client ListFindingAggregationsAPIClient, params *ListFindingAggregationsInput, optFns ...func(*ListFindingAggregationsPaginatorOptions)) *ListFindingAggregationsPaginator {
if params == nil {
params = &ListFindingAggregationsInput{}
}
options := ListFindingAggregationsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListFindingAggregationsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListFindingAggregationsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListFindingAggregations page.
func (p *ListFindingAggregationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListFindingAggregationsOutput, 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.ListFindingAggregations(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_opListFindingAggregations(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "ListFindingAggregations",
}
}
| 245 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists findings for your environment.
func (c *Client) ListFindings(ctx context.Context, params *ListFindingsInput, optFns ...func(*Options)) (*ListFindingsOutput, error) {
if params == nil {
params = &ListFindingsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListFindings", params, optFns, c.addOperationListFindingsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListFindingsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListFindingsInput struct {
// Details on the filters to apply to your finding results.
FilterCriteria *types.FilterCriteria
// The maximum number of results to return in the response.
MaxResults *int32
// A token to use for paginating results that are returned in the response. Set
// the value of this parameter to null for the first request to a list action. For
// subsequent calls, use the NextToken value returned from the previous request to
// continue listing results after the first page.
NextToken *string
// Details on the sort criteria to apply to your finding results.
SortCriteria *types.SortCriteria
noSmithyDocumentSerde
}
type ListFindingsOutput struct {
// Contains details on the findings in your environment.
Findings []types.Finding
// A token to use for paginating results that are returned in the response. Set
// the value of this parameter to null for the first request to a list action. For
// subsequent calls, use the NextToken value returned from the previous request to
// continue listing results after the first page.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListFindingsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListFindings{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListFindings{}, 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 = addOpListFindingsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListFindings(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
}
// ListFindingsAPIClient is a client that implements the ListFindings operation.
type ListFindingsAPIClient interface {
ListFindings(context.Context, *ListFindingsInput, ...func(*Options)) (*ListFindingsOutput, error)
}
var _ ListFindingsAPIClient = (*Client)(nil)
// ListFindingsPaginatorOptions is the paginator options for ListFindings
type ListFindingsPaginatorOptions struct {
// The maximum number of results to return in the response.
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
}
// ListFindingsPaginator is a paginator for ListFindings
type ListFindingsPaginator struct {
options ListFindingsPaginatorOptions
client ListFindingsAPIClient
params *ListFindingsInput
nextToken *string
firstPage bool
}
// NewListFindingsPaginator returns a new ListFindingsPaginator
func NewListFindingsPaginator(client ListFindingsAPIClient, params *ListFindingsInput, optFns ...func(*ListFindingsPaginatorOptions)) *ListFindingsPaginator {
if params == nil {
params = &ListFindingsInput{}
}
options := ListFindingsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListFindingsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListFindingsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListFindings page.
func (p *ListFindingsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListFindingsOutput, 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.ListFindings(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_opListFindings(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "ListFindings",
}
}
| 231 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// List members associated with the Amazon Inspector delegated administrator for
// your organization.
func (c *Client) ListMembers(ctx context.Context, params *ListMembersInput, optFns ...func(*Options)) (*ListMembersOutput, error) {
if params == nil {
params = &ListMembersInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListMembers", params, optFns, c.addOperationListMembersMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListMembersOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListMembersInput struct {
// The maximum number of results to return in the response.
MaxResults *int32
// A token to use for paginating results that are returned in the response. Set
// the value of this parameter to null for the first request to a list action. For
// subsequent calls, use the NextToken value returned from the previous request to
// continue listing results after the first page.
NextToken *string
// Specifies whether to list only currently associated members if True or to list
// all members within the organization if False .
OnlyAssociated *bool
noSmithyDocumentSerde
}
type ListMembersOutput struct {
// An object that contains details for each member account.
Members []types.Member
// The pagination parameter to be used on the next list operation to retrieve more
// items.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListMembersMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListMembers{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListMembers{}, 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_opListMembers(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
}
// ListMembersAPIClient is a client that implements the ListMembers operation.
type ListMembersAPIClient interface {
ListMembers(context.Context, *ListMembersInput, ...func(*Options)) (*ListMembersOutput, error)
}
var _ ListMembersAPIClient = (*Client)(nil)
// ListMembersPaginatorOptions is the paginator options for ListMembers
type ListMembersPaginatorOptions struct {
// The maximum number of results to return in the response.
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
}
// ListMembersPaginator is a paginator for ListMembers
type ListMembersPaginator struct {
options ListMembersPaginatorOptions
client ListMembersAPIClient
params *ListMembersInput
nextToken *string
firstPage bool
}
// NewListMembersPaginator returns a new ListMembersPaginator
func NewListMembersPaginator(client ListMembersAPIClient, params *ListMembersInput, optFns ...func(*ListMembersPaginatorOptions)) *ListMembersPaginator {
if params == nil {
params = &ListMembersInput{}
}
options := ListMembersPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListMembersPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListMembersPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListMembers page.
func (p *ListMembersPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListMembersOutput, 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.ListMembers(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_opListMembers(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "ListMembers",
}
}
| 225 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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 tags attached to a given resource.
func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error) {
if params == nil {
params = &ListTagsForResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListTagsForResource", params, optFns, c.addOperationListTagsForResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListTagsForResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListTagsForResourceInput struct {
// The Amazon resource number (ARN) of the resource to list tags of.
//
// This member is required.
ResourceArn *string
noSmithyDocumentSerde
}
type ListTagsForResourceOutput struct {
// The tags associated with the resource.
Tags map[string]string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListTagsForResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListTagsForResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListTagsForResource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpListTagsForResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListTagsForResource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opListTagsForResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "ListTagsForResource",
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists the Amazon Inspector usage totals over the last 30 days.
func (c *Client) ListUsageTotals(ctx context.Context, params *ListUsageTotalsInput, optFns ...func(*Options)) (*ListUsageTotalsOutput, error) {
if params == nil {
params = &ListUsageTotalsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListUsageTotals", params, optFns, c.addOperationListUsageTotalsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListUsageTotalsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListUsageTotalsInput struct {
// The Amazon Web Services account IDs to retrieve usage totals for.
AccountIds []string
// The maximum number of results to return in the response.
MaxResults *int32
// A token to use for paginating results that are returned in the response. Set
// the value of this parameter to null for the first request to a list action. For
// subsequent calls, use the NextToken value returned from the previous request to
// continue listing results after the first page.
NextToken *string
noSmithyDocumentSerde
}
type ListUsageTotalsOutput struct {
// The pagination parameter to be used on the next list operation to retrieve more
// items.
NextToken *string
// An object with details on the total usage for the requested account.
Totals []types.UsageTotal
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListUsageTotalsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpListUsageTotals{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpListUsageTotals{}, 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_opListUsageTotals(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
}
// ListUsageTotalsAPIClient is a client that implements the ListUsageTotals
// operation.
type ListUsageTotalsAPIClient interface {
ListUsageTotals(context.Context, *ListUsageTotalsInput, ...func(*Options)) (*ListUsageTotalsOutput, error)
}
var _ ListUsageTotalsAPIClient = (*Client)(nil)
// ListUsageTotalsPaginatorOptions is the paginator options for ListUsageTotals
type ListUsageTotalsPaginatorOptions struct {
// The maximum number of results to return in the response.
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
}
// ListUsageTotalsPaginator is a paginator for ListUsageTotals
type ListUsageTotalsPaginator struct {
options ListUsageTotalsPaginatorOptions
client ListUsageTotalsAPIClient
params *ListUsageTotalsInput
nextToken *string
firstPage bool
}
// NewListUsageTotalsPaginator returns a new ListUsageTotalsPaginator
func NewListUsageTotalsPaginator(client ListUsageTotalsAPIClient, params *ListUsageTotalsInput, optFns ...func(*ListUsageTotalsPaginatorOptions)) *ListUsageTotalsPaginator {
if params == nil {
params = &ListUsageTotalsInput{}
}
options := ListUsageTotalsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListUsageTotalsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListUsageTotalsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListUsageTotals page.
func (p *ListUsageTotalsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListUsageTotalsOutput, 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.ListUsageTotals(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_opListUsageTotals(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "ListUsageTotals",
}
}
| 224 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Resets an encryption key. After the key is reset your resources will be
// encrypted by an Amazon Web Services owned key.
func (c *Client) ResetEncryptionKey(ctx context.Context, params *ResetEncryptionKeyInput, optFns ...func(*Options)) (*ResetEncryptionKeyOutput, error) {
if params == nil {
params = &ResetEncryptionKeyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ResetEncryptionKey", params, optFns, c.addOperationResetEncryptionKeyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ResetEncryptionKeyOutput)
out.ResultMetadata = metadata
return out, nil
}
type ResetEncryptionKeyInput struct {
// The resource type the key encrypts.
//
// This member is required.
ResourceType types.ResourceType
// The scan type the key encrypts.
//
// This member is required.
ScanType types.ScanType
noSmithyDocumentSerde
}
type ResetEncryptionKeyOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationResetEncryptionKeyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpResetEncryptionKey{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpResetEncryptionKey{}, 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 = addOpResetEncryptionKeyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opResetEncryptionKey(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_opResetEncryptionKey(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "ResetEncryptionKey",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Lists Amazon Inspector coverage details for a specific vulnerability.
func (c *Client) SearchVulnerabilities(ctx context.Context, params *SearchVulnerabilitiesInput, optFns ...func(*Options)) (*SearchVulnerabilitiesOutput, error) {
if params == nil {
params = &SearchVulnerabilitiesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "SearchVulnerabilities", params, optFns, c.addOperationSearchVulnerabilitiesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*SearchVulnerabilitiesOutput)
out.ResultMetadata = metadata
return out, nil
}
type SearchVulnerabilitiesInput struct {
// The criteria used to filter the results of a vulnerability search.
//
// This member is required.
FilterCriteria *types.SearchVulnerabilitiesFilterCriteria
// A token to use for paginating results that are returned in the response. Set
// the value of this parameter to null for the first request to a list action. For
// subsequent calls, use the NextToken value returned from the previous request to
// continue listing results after the first page.
NextToken *string
noSmithyDocumentSerde
}
type SearchVulnerabilitiesOutput struct {
// Details about the listed vulnerability.
//
// This member is required.
Vulnerabilities []types.Vulnerability
// The pagination parameter to be used on the next list operation to retrieve more
// items.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationSearchVulnerabilitiesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpSearchVulnerabilities{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpSearchVulnerabilities{}, 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 = addOpSearchVulnerabilitiesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opSearchVulnerabilities(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
}
// SearchVulnerabilitiesAPIClient is a client that implements the
// SearchVulnerabilities operation.
type SearchVulnerabilitiesAPIClient interface {
SearchVulnerabilities(context.Context, *SearchVulnerabilitiesInput, ...func(*Options)) (*SearchVulnerabilitiesOutput, error)
}
var _ SearchVulnerabilitiesAPIClient = (*Client)(nil)
// SearchVulnerabilitiesPaginatorOptions is the paginator options for
// SearchVulnerabilities
type SearchVulnerabilitiesPaginatorOptions struct {
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// SearchVulnerabilitiesPaginator is a paginator for SearchVulnerabilities
type SearchVulnerabilitiesPaginator struct {
options SearchVulnerabilitiesPaginatorOptions
client SearchVulnerabilitiesAPIClient
params *SearchVulnerabilitiesInput
nextToken *string
firstPage bool
}
// NewSearchVulnerabilitiesPaginator returns a new SearchVulnerabilitiesPaginator
func NewSearchVulnerabilitiesPaginator(client SearchVulnerabilitiesAPIClient, params *SearchVulnerabilitiesInput, optFns ...func(*SearchVulnerabilitiesPaginatorOptions)) *SearchVulnerabilitiesPaginator {
if params == nil {
params = &SearchVulnerabilitiesInput{}
}
options := SearchVulnerabilitiesPaginatorOptions{}
for _, fn := range optFns {
fn(&options)
}
return &SearchVulnerabilitiesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *SearchVulnerabilitiesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next SearchVulnerabilities page.
func (p *SearchVulnerabilitiesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*SearchVulnerabilitiesOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
result, err := p.client.SearchVulnerabilities(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_opSearchVulnerabilities(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "SearchVulnerabilities",
}
}
| 217 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Adds tags to a resource.
func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error) {
if params == nil {
params = &TagResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "TagResource", params, optFns, c.addOperationTagResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*TagResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type TagResourceInput struct {
// The Amazon Resource Name (ARN) of the resource to apply a tag to.
//
// This member is required.
ResourceArn *string
// The tags to be added to a resource.
//
// This member is required.
Tags map[string]string
noSmithyDocumentSerde
}
type TagResourceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationTagResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpTagResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpTagResource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpTagResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opTagResource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opTagResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "TagResource",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Removes tags from 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) for the resource to remove tags from.
//
// This member is required.
ResourceArn *string
// The tag keys to remove from the resource.
//
// This member is required.
TagKeys []string
noSmithyDocumentSerde
}
type UntagResourceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUntagResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUntagResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUntagResource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpUntagResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUntagResource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opUntagResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "UntagResource",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates setting configurations for your Amazon Inspector account. When you use
// this API as an Amazon Inspector delegated administrator this updates the setting
// for all accounts you manage. Member accounts in an organization cannot update
// this setting.
func (c *Client) UpdateConfiguration(ctx context.Context, params *UpdateConfigurationInput, optFns ...func(*Options)) (*UpdateConfigurationOutput, error) {
if params == nil {
params = &UpdateConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateConfiguration", params, optFns, c.addOperationUpdateConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateConfigurationInput struct {
// Specifies how the ECR automated re-scan will be updated for your environment.
//
// This member is required.
EcrConfiguration *types.EcrConfiguration
noSmithyDocumentSerde
}
type UpdateConfigurationOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateConfiguration{}, 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 = addOpUpdateConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateConfiguration(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_opUpdateConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "UpdateConfiguration",
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Activates, deactivates Amazon Inspector deep inspection, or updates custom
// paths for your account.
func (c *Client) UpdateEc2DeepInspectionConfiguration(ctx context.Context, params *UpdateEc2DeepInspectionConfigurationInput, optFns ...func(*Options)) (*UpdateEc2DeepInspectionConfigurationOutput, error) {
if params == nil {
params = &UpdateEc2DeepInspectionConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateEc2DeepInspectionConfiguration", params, optFns, c.addOperationUpdateEc2DeepInspectionConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateEc2DeepInspectionConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateEc2DeepInspectionConfigurationInput struct {
// Specify TRUE to activate Amazon Inspector deep inspection in your account, or
// FALSE to deactivate. Member accounts in an organization cannot deactivate deep
// inspection, instead the delegated administrator for the organization can
// deactivate a member account using BatchUpdateMemberEc2DeepInspectionStatus (https://docs.aws.amazon.com/inspector/v2/APIReference/API_BatchUpdateMemberEc2DeepInspectionStatus.html)
// .
ActivateDeepInspection *bool
// The Amazon Inspector deep inspection custom paths you are adding for your
// account.
PackagePaths []string
noSmithyDocumentSerde
}
type UpdateEc2DeepInspectionConfigurationOutput struct {
// An error message explaining why new Amazon Inspector deep inspection custom
// paths could not be added.
ErrorMessage *string
// The current Amazon Inspector deep inspection custom paths for the organization.
OrgPackagePaths []string
// The current Amazon Inspector deep inspection custom paths for your account.
PackagePaths []string
// The status of Amazon Inspector deep inspection in your account.
Status types.Ec2DeepInspectionStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateEc2DeepInspectionConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateEc2DeepInspectionConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateEc2DeepInspectionConfiguration{}, 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_opUpdateEc2DeepInspectionConfiguration(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_opUpdateEc2DeepInspectionConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "UpdateEc2DeepInspectionConfiguration",
}
}
| 139 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates an encryption key. A ResourceNotFoundException means that an AWS owned
// key is being used for encryption.
func (c *Client) UpdateEncryptionKey(ctx context.Context, params *UpdateEncryptionKeyInput, optFns ...func(*Options)) (*UpdateEncryptionKeyOutput, error) {
if params == nil {
params = &UpdateEncryptionKeyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateEncryptionKey", params, optFns, c.addOperationUpdateEncryptionKeyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateEncryptionKeyOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateEncryptionKeyInput struct {
// A KMS key ID for the encryption key.
//
// This member is required.
KmsKeyId *string
// The resource type for the encryption key.
//
// This member is required.
ResourceType types.ResourceType
// The scan type for the encryption key.
//
// This member is required.
ScanType types.ScanType
noSmithyDocumentSerde
}
type UpdateEncryptionKeyOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateEncryptionKeyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateEncryptionKey{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateEncryptionKey{}, 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 = addOpUpdateEncryptionKeyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateEncryptionKey(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_opUpdateEncryptionKey(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "UpdateEncryptionKey",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Specifies the action that is to be applied to the findings that match the
// filter.
func (c *Client) UpdateFilter(ctx context.Context, params *UpdateFilterInput, optFns ...func(*Options)) (*UpdateFilterOutput, error) {
if params == nil {
params = &UpdateFilterInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateFilter", params, optFns, c.addOperationUpdateFilterMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateFilterOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateFilterInput struct {
// The Amazon Resource Number (ARN) of the filter to update.
//
// This member is required.
FilterArn *string
// Specifies the action that is to be applied to the findings that match the
// filter.
Action types.FilterAction
// A description of the filter.
Description *string
// Defines the criteria to be update in the filter.
FilterCriteria *types.FilterCriteria
// The name of the filter.
Name *string
// The reason the filter was updated.
Reason *string
noSmithyDocumentSerde
}
type UpdateFilterOutput struct {
// The Amazon Resource Number (ARN) of the successfully updated filter.
//
// This member is required.
Arn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateFilterMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateFilter{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateFilter{}, 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 = addOpUpdateFilterValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateFilter(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_opUpdateFilter(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "UpdateFilter",
}
}
| 144 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Updates the configurations for your Amazon Inspector organization.
func (c *Client) UpdateOrganizationConfiguration(ctx context.Context, params *UpdateOrganizationConfigurationInput, optFns ...func(*Options)) (*UpdateOrganizationConfigurationOutput, error) {
if params == nil {
params = &UpdateOrganizationConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateOrganizationConfiguration", params, optFns, c.addOperationUpdateOrganizationConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateOrganizationConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateOrganizationConfigurationInput struct {
// Defines which scan types are enabled automatically for new members of your
// Amazon Inspector organization.
//
// This member is required.
AutoEnable *types.AutoEnable
noSmithyDocumentSerde
}
type UpdateOrganizationConfigurationOutput struct {
// The updated status of scan types automatically enabled for new members of your
// Amazon Inspector organization.
//
// This member is required.
AutoEnable *types.AutoEnable
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateOrganizationConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateOrganizationConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateOrganizationConfiguration{}, 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 = addOpUpdateOrganizationConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateOrganizationConfiguration(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_opUpdateOrganizationConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "UpdateOrganizationConfiguration",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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"
)
// Updates the Amazon Inspector deep inspection custom paths for your
// organization. You must be an Amazon Inspector delegated administrator to use
// this API.
func (c *Client) UpdateOrgEc2DeepInspectionConfiguration(ctx context.Context, params *UpdateOrgEc2DeepInspectionConfigurationInput, optFns ...func(*Options)) (*UpdateOrgEc2DeepInspectionConfigurationOutput, error) {
if params == nil {
params = &UpdateOrgEc2DeepInspectionConfigurationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UpdateOrgEc2DeepInspectionConfiguration", params, optFns, c.addOperationUpdateOrgEc2DeepInspectionConfigurationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UpdateOrgEc2DeepInspectionConfigurationOutput)
out.ResultMetadata = metadata
return out, nil
}
type UpdateOrgEc2DeepInspectionConfigurationInput struct {
// The Amazon Inspector deep inspection custom paths you are adding for your
// organization.
//
// This member is required.
OrgPackagePaths []string
noSmithyDocumentSerde
}
type UpdateOrgEc2DeepInspectionConfigurationOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationUpdateOrgEc2DeepInspectionConfigurationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsRestjson1_serializeOpUpdateOrgEc2DeepInspectionConfiguration{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpUpdateOrgEc2DeepInspectionConfiguration{}, 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 = addOpUpdateOrgEc2DeepInspectionConfigurationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUpdateOrgEc2DeepInspectionConfiguration(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_opUpdateOrgEc2DeepInspectionConfiguration(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "inspector2",
OperationName: "UpdateOrgEc2DeepInspectionConfiguration",
}
}
| 123 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
import (
"bytes"
"context"
"encoding/json"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
"github.com/aws/aws-sdk-go-v2/service/inspector2/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"
"strconv"
"strings"
)
type awsRestjson1_deserializeOpAssociateMember struct {
}
func (*awsRestjson1_deserializeOpAssociateMember) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpAssociateMember) 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_deserializeOpErrorAssociateMember(response, &metadata)
}
output := &AssociateMemberOutput{}
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_deserializeOpDocumentAssociateMemberOutput(&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_deserializeOpErrorAssociateMember(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentAssociateMemberOutput(v **AssociateMemberOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *AssociateMemberOutput
if *v == nil {
sv = &AssociateMemberOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpBatchGetAccountStatus struct {
}
func (*awsRestjson1_deserializeOpBatchGetAccountStatus) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpBatchGetAccountStatus) 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_deserializeOpErrorBatchGetAccountStatus(response, &metadata)
}
output := &BatchGetAccountStatusOutput{}
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_deserializeOpDocumentBatchGetAccountStatusOutput(&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_deserializeOpErrorBatchGetAccountStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentBatchGetAccountStatusOutput(v **BatchGetAccountStatusOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *BatchGetAccountStatusOutput
if *v == nil {
sv = &BatchGetAccountStatusOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accounts":
if err := awsRestjson1_deserializeDocumentAccountStateList(&sv.Accounts, value); err != nil {
return err
}
case "failedAccounts":
if err := awsRestjson1_deserializeDocumentFailedAccountList(&sv.FailedAccounts, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpBatchGetCodeSnippet struct {
}
func (*awsRestjson1_deserializeOpBatchGetCodeSnippet) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpBatchGetCodeSnippet) 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_deserializeOpErrorBatchGetCodeSnippet(response, &metadata)
}
output := &BatchGetCodeSnippetOutput{}
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_deserializeOpDocumentBatchGetCodeSnippetOutput(&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_deserializeOpErrorBatchGetCodeSnippet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentBatchGetCodeSnippetOutput(v **BatchGetCodeSnippetOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *BatchGetCodeSnippetOutput
if *v == nil {
sv = &BatchGetCodeSnippetOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "codeSnippetResults":
if err := awsRestjson1_deserializeDocumentCodeSnippetResultList(&sv.CodeSnippetResults, value); err != nil {
return err
}
case "errors":
if err := awsRestjson1_deserializeDocumentCodeSnippetErrorList(&sv.Errors, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpBatchGetFreeTrialInfo struct {
}
func (*awsRestjson1_deserializeOpBatchGetFreeTrialInfo) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpBatchGetFreeTrialInfo) 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_deserializeOpErrorBatchGetFreeTrialInfo(response, &metadata)
}
output := &BatchGetFreeTrialInfoOutput{}
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_deserializeOpDocumentBatchGetFreeTrialInfoOutput(&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_deserializeOpErrorBatchGetFreeTrialInfo(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentBatchGetFreeTrialInfoOutput(v **BatchGetFreeTrialInfoOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *BatchGetFreeTrialInfoOutput
if *v == nil {
sv = &BatchGetFreeTrialInfoOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accounts":
if err := awsRestjson1_deserializeDocumentFreeTrialAccountInfoList(&sv.Accounts, value); err != nil {
return err
}
case "failedAccounts":
if err := awsRestjson1_deserializeDocumentFreeTrialInfoErrorList(&sv.FailedAccounts, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpBatchGetMemberEc2DeepInspectionStatus struct {
}
func (*awsRestjson1_deserializeOpBatchGetMemberEc2DeepInspectionStatus) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpBatchGetMemberEc2DeepInspectionStatus) 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_deserializeOpErrorBatchGetMemberEc2DeepInspectionStatus(response, &metadata)
}
output := &BatchGetMemberEc2DeepInspectionStatusOutput{}
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_deserializeOpDocumentBatchGetMemberEc2DeepInspectionStatusOutput(&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_deserializeOpErrorBatchGetMemberEc2DeepInspectionStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentBatchGetMemberEc2DeepInspectionStatusOutput(v **BatchGetMemberEc2DeepInspectionStatusOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *BatchGetMemberEc2DeepInspectionStatusOutput
if *v == nil {
sv = &BatchGetMemberEc2DeepInspectionStatusOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountIds":
if err := awsRestjson1_deserializeDocumentMemberAccountEc2DeepInspectionStatusStateList(&sv.AccountIds, value); err != nil {
return err
}
case "failedAccountIds":
if err := awsRestjson1_deserializeDocumentFailedMemberAccountEc2DeepInspectionStatusStateList(&sv.FailedAccountIds, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpBatchUpdateMemberEc2DeepInspectionStatus struct {
}
func (*awsRestjson1_deserializeOpBatchUpdateMemberEc2DeepInspectionStatus) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpBatchUpdateMemberEc2DeepInspectionStatus) 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_deserializeOpErrorBatchUpdateMemberEc2DeepInspectionStatus(response, &metadata)
}
output := &BatchUpdateMemberEc2DeepInspectionStatusOutput{}
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_deserializeOpDocumentBatchUpdateMemberEc2DeepInspectionStatusOutput(&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_deserializeOpErrorBatchUpdateMemberEc2DeepInspectionStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentBatchUpdateMemberEc2DeepInspectionStatusOutput(v **BatchUpdateMemberEc2DeepInspectionStatusOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *BatchUpdateMemberEc2DeepInspectionStatusOutput
if *v == nil {
sv = &BatchUpdateMemberEc2DeepInspectionStatusOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountIds":
if err := awsRestjson1_deserializeDocumentMemberAccountEc2DeepInspectionStatusStateList(&sv.AccountIds, value); err != nil {
return err
}
case "failedAccountIds":
if err := awsRestjson1_deserializeDocumentFailedMemberAccountEc2DeepInspectionStatusStateList(&sv.FailedAccountIds, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpCancelFindingsReport struct {
}
func (*awsRestjson1_deserializeOpCancelFindingsReport) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpCancelFindingsReport) 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_deserializeOpErrorCancelFindingsReport(response, &metadata)
}
output := &CancelFindingsReportOutput{}
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_deserializeOpDocumentCancelFindingsReportOutput(&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_deserializeOpErrorCancelFindingsReport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentCancelFindingsReportOutput(v **CancelFindingsReportOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *CancelFindingsReportOutput
if *v == nil {
sv = &CancelFindingsReportOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "reportId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ReportId to be of type string, got %T instead", value)
}
sv.ReportId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpCancelSbomExport struct {
}
func (*awsRestjson1_deserializeOpCancelSbomExport) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpCancelSbomExport) 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_deserializeOpErrorCancelSbomExport(response, &metadata)
}
output := &CancelSbomExportOutput{}
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_deserializeOpDocumentCancelSbomExportOutput(&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_deserializeOpErrorCancelSbomExport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentCancelSbomExportOutput(v **CancelSbomExportOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *CancelSbomExportOutput
if *v == nil {
sv = &CancelSbomExportOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "reportId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ReportId to be of type string, got %T instead", value)
}
sv.ReportId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpCreateFilter struct {
}
func (*awsRestjson1_deserializeOpCreateFilter) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpCreateFilter) 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_deserializeOpErrorCreateFilter(response, &metadata)
}
output := &CreateFilterOutput{}
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_deserializeOpDocumentCreateFilterOutput(&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_deserializeOpErrorCreateFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("BadRequestException", errorCode):
return awsRestjson1_deserializeErrorBadRequestException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ServiceQuotaExceededException", errorCode):
return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentCreateFilterOutput(v **CreateFilterOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *CreateFilterOutput
if *v == nil {
sv = &CreateFilterOutput{}
} 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 FilterArn to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpCreateFindingsReport struct {
}
func (*awsRestjson1_deserializeOpCreateFindingsReport) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpCreateFindingsReport) 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_deserializeOpErrorCreateFindingsReport(response, &metadata)
}
output := &CreateFindingsReportOutput{}
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_deserializeOpDocumentCreateFindingsReportOutput(&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_deserializeOpErrorCreateFindingsReport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentCreateFindingsReportOutput(v **CreateFindingsReportOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *CreateFindingsReportOutput
if *v == nil {
sv = &CreateFindingsReportOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "reportId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ReportId to be of type string, got %T instead", value)
}
sv.ReportId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpCreateSbomExport struct {
}
func (*awsRestjson1_deserializeOpCreateSbomExport) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpCreateSbomExport) 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_deserializeOpErrorCreateSbomExport(response, &metadata)
}
output := &CreateSbomExportOutput{}
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_deserializeOpDocumentCreateSbomExportOutput(&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_deserializeOpErrorCreateSbomExport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentCreateSbomExportOutput(v **CreateSbomExportOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *CreateSbomExportOutput
if *v == nil {
sv = &CreateSbomExportOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "reportId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ReportId to be of type string, got %T instead", value)
}
sv.ReportId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDeleteFilter struct {
}
func (*awsRestjson1_deserializeOpDeleteFilter) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDeleteFilter) 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_deserializeOpErrorDeleteFilter(response, &metadata)
}
output := &DeleteFilterOutput{}
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_deserializeOpDocumentDeleteFilterOutput(&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_deserializeOpErrorDeleteFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDeleteFilterOutput(v **DeleteFilterOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DeleteFilterOutput
if *v == nil {
sv = &DeleteFilterOutput{}
} 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 FilterArn to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDescribeOrganizationConfiguration struct {
}
func (*awsRestjson1_deserializeOpDescribeOrganizationConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDescribeOrganizationConfiguration) 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_deserializeOpErrorDescribeOrganizationConfiguration(response, &metadata)
}
output := &DescribeOrganizationConfigurationOutput{}
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_deserializeOpDocumentDescribeOrganizationConfigurationOutput(&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_deserializeOpErrorDescribeOrganizationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDescribeOrganizationConfigurationOutput(v **DescribeOrganizationConfigurationOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DescribeOrganizationConfigurationOutput
if *v == nil {
sv = &DescribeOrganizationConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "autoEnable":
if err := awsRestjson1_deserializeDocumentAutoEnable(&sv.AutoEnable, value); err != nil {
return err
}
case "maxAccountLimitReached":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.MaxAccountLimitReached = ptr.Bool(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDisable struct {
}
func (*awsRestjson1_deserializeOpDisable) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDisable) 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_deserializeOpErrorDisable(response, &metadata)
}
output := &DisableOutput{}
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_deserializeOpDocumentDisableOutput(&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_deserializeOpErrorDisable(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDisableOutput(v **DisableOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DisableOutput
if *v == nil {
sv = &DisableOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accounts":
if err := awsRestjson1_deserializeDocumentAccountList(&sv.Accounts, value); err != nil {
return err
}
case "failedAccounts":
if err := awsRestjson1_deserializeDocumentFailedAccountList(&sv.FailedAccounts, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDisableDelegatedAdminAccount struct {
}
func (*awsRestjson1_deserializeOpDisableDelegatedAdminAccount) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDisableDelegatedAdminAccount) 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_deserializeOpErrorDisableDelegatedAdminAccount(response, &metadata)
}
output := &DisableDelegatedAdminAccountOutput{}
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_deserializeOpDocumentDisableDelegatedAdminAccountOutput(&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_deserializeOpErrorDisableDelegatedAdminAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConflictException", errorCode):
return awsRestjson1_deserializeErrorConflictException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDisableDelegatedAdminAccountOutput(v **DisableDelegatedAdminAccountOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DisableDelegatedAdminAccountOutput
if *v == nil {
sv = &DisableDelegatedAdminAccountOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "delegatedAdminAccountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.DelegatedAdminAccountId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpDisassociateMember struct {
}
func (*awsRestjson1_deserializeOpDisassociateMember) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpDisassociateMember) 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_deserializeOpErrorDisassociateMember(response, &metadata)
}
output := &DisassociateMemberOutput{}
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_deserializeOpDocumentDisassociateMemberOutput(&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_deserializeOpErrorDisassociateMember(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentDisassociateMemberOutput(v **DisassociateMemberOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DisassociateMemberOutput
if *v == nil {
sv = &DisassociateMemberOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpEnable struct {
}
func (*awsRestjson1_deserializeOpEnable) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpEnable) 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_deserializeOpErrorEnable(response, &metadata)
}
output := &EnableOutput{}
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_deserializeOpDocumentEnableOutput(&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_deserializeOpErrorEnable(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentEnableOutput(v **EnableOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *EnableOutput
if *v == nil {
sv = &EnableOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accounts":
if err := awsRestjson1_deserializeDocumentAccountList(&sv.Accounts, value); err != nil {
return err
}
case "failedAccounts":
if err := awsRestjson1_deserializeDocumentFailedAccountList(&sv.FailedAccounts, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpEnableDelegatedAdminAccount struct {
}
func (*awsRestjson1_deserializeOpEnableDelegatedAdminAccount) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpEnableDelegatedAdminAccount) 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_deserializeOpErrorEnableDelegatedAdminAccount(response, &metadata)
}
output := &EnableDelegatedAdminAccountOutput{}
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_deserializeOpDocumentEnableDelegatedAdminAccountOutput(&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_deserializeOpErrorEnableDelegatedAdminAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("ConflictException", errorCode):
return awsRestjson1_deserializeErrorConflictException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentEnableDelegatedAdminAccountOutput(v **EnableDelegatedAdminAccountOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *EnableDelegatedAdminAccountOutput
if *v == nil {
sv = &EnableDelegatedAdminAccountOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "delegatedAdminAccountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.DelegatedAdminAccountId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetConfiguration struct {
}
func (*awsRestjson1_deserializeOpGetConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetConfiguration) 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_deserializeOpErrorGetConfiguration(response, &metadata)
}
output := &GetConfigurationOutput{}
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_deserializeOpDocumentGetConfigurationOutput(&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_deserializeOpErrorGetConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetConfigurationOutput(v **GetConfigurationOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetConfigurationOutput
if *v == nil {
sv = &GetConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ecrConfiguration":
if err := awsRestjson1_deserializeDocumentEcrConfigurationState(&sv.EcrConfiguration, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetDelegatedAdminAccount struct {
}
func (*awsRestjson1_deserializeOpGetDelegatedAdminAccount) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetDelegatedAdminAccount) 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_deserializeOpErrorGetDelegatedAdminAccount(response, &metadata)
}
output := &GetDelegatedAdminAccountOutput{}
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_deserializeOpDocumentGetDelegatedAdminAccountOutput(&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_deserializeOpErrorGetDelegatedAdminAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetDelegatedAdminAccountOutput(v **GetDelegatedAdminAccountOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetDelegatedAdminAccountOutput
if *v == nil {
sv = &GetDelegatedAdminAccountOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "delegatedAdmin":
if err := awsRestjson1_deserializeDocumentDelegatedAdmin(&sv.DelegatedAdmin, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetEc2DeepInspectionConfiguration struct {
}
func (*awsRestjson1_deserializeOpGetEc2DeepInspectionConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetEc2DeepInspectionConfiguration) 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_deserializeOpErrorGetEc2DeepInspectionConfiguration(response, &metadata)
}
output := &GetEc2DeepInspectionConfigurationOutput{}
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_deserializeOpDocumentGetEc2DeepInspectionConfigurationOutput(&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_deserializeOpErrorGetEc2DeepInspectionConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetEc2DeepInspectionConfigurationOutput(v **GetEc2DeepInspectionConfigurationOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetEc2DeepInspectionConfigurationOutput
if *v == nil {
sv = &GetEc2DeepInspectionConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "errorMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.ErrorMessage = ptr.String(jtv)
}
case "orgPackagePaths":
if err := awsRestjson1_deserializeDocumentPathList(&sv.OrgPackagePaths, value); err != nil {
return err
}
case "packagePaths":
if err := awsRestjson1_deserializeDocumentPathList(&sv.PackagePaths, value); err != nil {
return err
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Ec2DeepInspectionStatus to be of type string, got %T instead", value)
}
sv.Status = types.Ec2DeepInspectionStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetEncryptionKey struct {
}
func (*awsRestjson1_deserializeOpGetEncryptionKey) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetEncryptionKey) 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_deserializeOpErrorGetEncryptionKey(response, &metadata)
}
output := &GetEncryptionKeyOutput{}
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_deserializeOpDocumentGetEncryptionKeyOutput(&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_deserializeOpErrorGetEncryptionKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetEncryptionKeyOutput(v **GetEncryptionKeyOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetEncryptionKeyOutput
if *v == nil {
sv = &GetEncryptionKeyOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "kmsKeyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected KmsKeyArn to be of type string, got %T instead", value)
}
sv.KmsKeyId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetFindingsReportStatus struct {
}
func (*awsRestjson1_deserializeOpGetFindingsReportStatus) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetFindingsReportStatus) 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_deserializeOpErrorGetFindingsReportStatus(response, &metadata)
}
output := &GetFindingsReportStatusOutput{}
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_deserializeOpDocumentGetFindingsReportStatusOutput(&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_deserializeOpErrorGetFindingsReportStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetFindingsReportStatusOutput(v **GetFindingsReportStatusOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetFindingsReportStatusOutput
if *v == nil {
sv = &GetFindingsReportStatusOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "destination":
if err := awsRestjson1_deserializeDocumentDestination(&sv.Destination, value); err != nil {
return err
}
case "errorCode":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ReportingErrorCode to be of type string, got %T instead", value)
}
sv.ErrorCode = types.ReportingErrorCode(jtv)
}
case "errorMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
}
sv.ErrorMessage = ptr.String(jtv)
}
case "filterCriteria":
if err := awsRestjson1_deserializeDocumentFilterCriteria(&sv.FilterCriteria, value); err != nil {
return err
}
case "reportId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ReportId to be of type string, got %T instead", value)
}
sv.ReportId = ptr.String(jtv)
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ExternalReportStatus to be of type string, got %T instead", value)
}
sv.Status = types.ExternalReportStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetMember struct {
}
func (*awsRestjson1_deserializeOpGetMember) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetMember) 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_deserializeOpErrorGetMember(response, &metadata)
}
output := &GetMemberOutput{}
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_deserializeOpDocumentGetMemberOutput(&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_deserializeOpErrorGetMember(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetMemberOutput(v **GetMemberOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetMemberOutput
if *v == nil {
sv = &GetMemberOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "member":
if err := awsRestjson1_deserializeDocumentMember(&sv.Member, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpGetSbomExport struct {
}
func (*awsRestjson1_deserializeOpGetSbomExport) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpGetSbomExport) 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_deserializeOpErrorGetSbomExport(response, &metadata)
}
output := &GetSbomExportOutput{}
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_deserializeOpDocumentGetSbomExportOutput(&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_deserializeOpErrorGetSbomExport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentGetSbomExportOutput(v **GetSbomExportOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetSbomExportOutput
if *v == nil {
sv = &GetSbomExportOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "errorCode":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ReportingErrorCode to be of type string, got %T instead", value)
}
sv.ErrorCode = types.ReportingErrorCode(jtv)
}
case "errorMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.ErrorMessage = ptr.String(jtv)
}
case "filterCriteria":
if err := awsRestjson1_deserializeDocumentResourceFilterCriteria(&sv.FilterCriteria, value); err != nil {
return err
}
case "format":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SbomReportFormat to be of type string, got %T instead", value)
}
sv.Format = types.SbomReportFormat(jtv)
}
case "reportId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ReportId to be of type string, got %T instead", value)
}
sv.ReportId = ptr.String(jtv)
}
case "s3Destination":
if err := awsRestjson1_deserializeDocumentDestination(&sv.S3Destination, value); err != nil {
return err
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ExternalReportStatus to be of type string, got %T instead", value)
}
sv.Status = types.ExternalReportStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListAccountPermissions struct {
}
func (*awsRestjson1_deserializeOpListAccountPermissions) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListAccountPermissions) 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_deserializeOpErrorListAccountPermissions(response, &metadata)
}
output := &ListAccountPermissionsOutput{}
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_deserializeOpDocumentListAccountPermissionsOutput(&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_deserializeOpErrorListAccountPermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListAccountPermissionsOutput(v **ListAccountPermissionsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListAccountPermissionsOutput
if *v == nil {
sv = &ListAccountPermissionsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "nextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "permissions":
if err := awsRestjson1_deserializeDocumentPermissions(&sv.Permissions, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListCoverage struct {
}
func (*awsRestjson1_deserializeOpListCoverage) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListCoverage) 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_deserializeOpErrorListCoverage(response, &metadata)
}
output := &ListCoverageOutput{}
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_deserializeOpDocumentListCoverageOutput(&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_deserializeOpErrorListCoverage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListCoverageOutput(v **ListCoverageOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListCoverageOutput
if *v == nil {
sv = &ListCoverageOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "coveredResources":
if err := awsRestjson1_deserializeDocumentCoveredResources(&sv.CoveredResources, value); err != nil {
return err
}
case "nextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListCoverageStatistics struct {
}
func (*awsRestjson1_deserializeOpListCoverageStatistics) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListCoverageStatistics) 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_deserializeOpErrorListCoverageStatistics(response, &metadata)
}
output := &ListCoverageStatisticsOutput{}
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_deserializeOpDocumentListCoverageStatisticsOutput(&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_deserializeOpErrorListCoverageStatistics(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListCoverageStatisticsOutput(v **ListCoverageStatisticsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListCoverageStatisticsOutput
if *v == nil {
sv = &ListCoverageStatisticsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "countsByGroup":
if err := awsRestjson1_deserializeDocumentCountsList(&sv.CountsByGroup, value); err != nil {
return err
}
case "nextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "totalCounts":
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.TotalCounts = ptr.Int64(i64)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListDelegatedAdminAccounts struct {
}
func (*awsRestjson1_deserializeOpListDelegatedAdminAccounts) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListDelegatedAdminAccounts) 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_deserializeOpErrorListDelegatedAdminAccounts(response, &metadata)
}
output := &ListDelegatedAdminAccountsOutput{}
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_deserializeOpDocumentListDelegatedAdminAccountsOutput(&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_deserializeOpErrorListDelegatedAdminAccounts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListDelegatedAdminAccountsOutput(v **ListDelegatedAdminAccountsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListDelegatedAdminAccountsOutput
if *v == nil {
sv = &ListDelegatedAdminAccountsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "delegatedAdminAccounts":
if err := awsRestjson1_deserializeDocumentDelegatedAdminAccountList(&sv.DelegatedAdminAccounts, value); err != nil {
return err
}
case "nextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListFilters struct {
}
func (*awsRestjson1_deserializeOpListFilters) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListFilters) 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_deserializeOpErrorListFilters(response, &metadata)
}
output := &ListFiltersOutput{}
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_deserializeOpDocumentListFiltersOutput(&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_deserializeOpErrorListFilters(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListFiltersOutput(v **ListFiltersOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListFiltersOutput
if *v == nil {
sv = &ListFiltersOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "filters":
if err := awsRestjson1_deserializeDocumentFilterList(&sv.Filters, value); err != nil {
return err
}
case "nextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListFindingAggregations struct {
}
func (*awsRestjson1_deserializeOpListFindingAggregations) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListFindingAggregations) 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_deserializeOpErrorListFindingAggregations(response, &metadata)
}
output := &ListFindingAggregationsOutput{}
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_deserializeOpDocumentListFindingAggregationsOutput(&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_deserializeOpErrorListFindingAggregations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListFindingAggregationsOutput(v **ListFindingAggregationsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListFindingAggregationsOutput
if *v == nil {
sv = &ListFindingAggregationsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "aggregationType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AggregationType to be of type string, got %T instead", value)
}
sv.AggregationType = types.AggregationType(jtv)
}
case "nextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "responses":
if err := awsRestjson1_deserializeDocumentAggregationResponseList(&sv.Responses, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListFindings struct {
}
func (*awsRestjson1_deserializeOpListFindings) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListFindings) 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_deserializeOpErrorListFindings(response, &metadata)
}
output := &ListFindingsOutput{}
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_deserializeOpDocumentListFindingsOutput(&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_deserializeOpErrorListFindings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListFindingsOutput(v **ListFindingsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListFindingsOutput
if *v == nil {
sv = &ListFindingsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "findings":
if err := awsRestjson1_deserializeDocumentFindingList(&sv.Findings, value); err != nil {
return err
}
case "nextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListMembers struct {
}
func (*awsRestjson1_deserializeOpListMembers) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListMembers) 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_deserializeOpErrorListMembers(response, &metadata)
}
output := &ListMembersOutput{}
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_deserializeOpDocumentListMembersOutput(&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_deserializeOpErrorListMembers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListMembersOutput(v **ListMembersOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListMembersOutput
if *v == nil {
sv = &ListMembersOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "members":
if err := awsRestjson1_deserializeDocumentMemberList(&sv.Members, value); err != nil {
return err
}
case "nextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListTagsForResource struct {
}
func (*awsRestjson1_deserializeOpListTagsForResource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorListTagsForResource(response, &metadata)
}
output := &ListTagsForResourceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
Snapshot: snapshot.Bytes(),
}
}
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListTagsForResourceOutput
if *v == nil {
sv = &ListTagsForResourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "tags":
if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpListUsageTotals struct {
}
func (*awsRestjson1_deserializeOpListUsageTotals) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpListUsageTotals) 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_deserializeOpErrorListUsageTotals(response, &metadata)
}
output := &ListUsageTotalsOutput{}
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_deserializeOpDocumentListUsageTotalsOutput(&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_deserializeOpErrorListUsageTotals(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentListUsageTotalsOutput(v **ListUsageTotalsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListUsageTotalsOutput
if *v == nil {
sv = &ListUsageTotalsOutput{}
} 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 ListUsageTotalsNextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "totals":
if err := awsRestjson1_deserializeDocumentUsageTotalList(&sv.Totals, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpResetEncryptionKey struct {
}
func (*awsRestjson1_deserializeOpResetEncryptionKey) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpResetEncryptionKey) 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_deserializeOpErrorResetEncryptionKey(response, &metadata)
}
output := &ResetEncryptionKeyOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorResetEncryptionKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpSearchVulnerabilities struct {
}
func (*awsRestjson1_deserializeOpSearchVulnerabilities) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpSearchVulnerabilities) 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_deserializeOpErrorSearchVulnerabilities(response, &metadata)
}
output := &SearchVulnerabilitiesOutput{}
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_deserializeOpDocumentSearchVulnerabilitiesOutput(&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_deserializeOpErrorSearchVulnerabilities(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentSearchVulnerabilitiesOutput(v **SearchVulnerabilitiesOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *SearchVulnerabilitiesOutput
if *v == nil {
sv = &SearchVulnerabilitiesOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "nextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "vulnerabilities":
if err := awsRestjson1_deserializeDocumentVulnerabilities(&sv.Vulnerabilities, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpTagResource struct {
}
func (*awsRestjson1_deserializeOpTagResource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorTagResource(response, &metadata)
}
output := &TagResourceOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("BadRequestException", errorCode):
return awsRestjson1_deserializeErrorBadRequestException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpUntagResource struct {
}
func (*awsRestjson1_deserializeOpUntagResource) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsRestjson1_deserializeOpErrorUntagResource(response, &metadata)
}
output := &UntagResourceOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpUpdateConfiguration struct {
}
func (*awsRestjson1_deserializeOpUpdateConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateConfiguration) 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_deserializeOpErrorUpdateConfiguration(response, &metadata)
}
output := &UpdateConfigurationOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorUpdateConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpUpdateEc2DeepInspectionConfiguration struct {
}
func (*awsRestjson1_deserializeOpUpdateEc2DeepInspectionConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateEc2DeepInspectionConfiguration) 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_deserializeOpErrorUpdateEc2DeepInspectionConfiguration(response, &metadata)
}
output := &UpdateEc2DeepInspectionConfigurationOutput{}
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_deserializeOpDocumentUpdateEc2DeepInspectionConfigurationOutput(&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_deserializeOpErrorUpdateEc2DeepInspectionConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentUpdateEc2DeepInspectionConfigurationOutput(v **UpdateEc2DeepInspectionConfigurationOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *UpdateEc2DeepInspectionConfigurationOutput
if *v == nil {
sv = &UpdateEc2DeepInspectionConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "errorMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.ErrorMessage = ptr.String(jtv)
}
case "orgPackagePaths":
if err := awsRestjson1_deserializeDocumentPathList(&sv.OrgPackagePaths, value); err != nil {
return err
}
case "packagePaths":
if err := awsRestjson1_deserializeDocumentPathList(&sv.PackagePaths, value); err != nil {
return err
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Ec2DeepInspectionStatus to be of type string, got %T instead", value)
}
sv.Status = types.Ec2DeepInspectionStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpUpdateEncryptionKey struct {
}
func (*awsRestjson1_deserializeOpUpdateEncryptionKey) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateEncryptionKey) 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_deserializeOpErrorUpdateEncryptionKey(response, &metadata)
}
output := &UpdateEncryptionKeyOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorUpdateEncryptionKey(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsRestjson1_deserializeOpUpdateFilter struct {
}
func (*awsRestjson1_deserializeOpUpdateFilter) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateFilter) 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_deserializeOpErrorUpdateFilter(response, &metadata)
}
output := &UpdateFilterOutput{}
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_deserializeOpDocumentUpdateFilterOutput(&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_deserializeOpErrorUpdateFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentUpdateFilterOutput(v **UpdateFilterOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *UpdateFilterOutput
if *v == nil {
sv = &UpdateFilterOutput{}
} 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 FilterArn to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpUpdateOrganizationConfiguration struct {
}
func (*awsRestjson1_deserializeOpUpdateOrganizationConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateOrganizationConfiguration) 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_deserializeOpErrorUpdateOrganizationConfiguration(response, &metadata)
}
output := &UpdateOrganizationConfigurationOutput{}
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_deserializeOpDocumentUpdateOrganizationConfigurationOutput(&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_deserializeOpErrorUpdateOrganizationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpDocumentUpdateOrganizationConfigurationOutput(v **UpdateOrganizationConfigurationOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *UpdateOrganizationConfigurationOutput
if *v == nil {
sv = &UpdateOrganizationConfigurationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "autoEnable":
if err := awsRestjson1_deserializeDocumentAutoEnable(&sv.AutoEnable, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
type awsRestjson1_deserializeOpUpdateOrgEc2DeepInspectionConfiguration struct {
}
func (*awsRestjson1_deserializeOpUpdateOrgEc2DeepInspectionConfiguration) ID() string {
return "OperationDeserializer"
}
func (m *awsRestjson1_deserializeOpUpdateOrgEc2DeepInspectionConfiguration) 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_deserializeOpErrorUpdateOrgEc2DeepInspectionConfiguration(response, &metadata)
}
output := &UpdateOrgEc2DeepInspectionConfigurationOutput{}
out.Result = output
return out, metadata, err
}
func awsRestjson1_deserializeOpErrorUpdateOrgEc2DeepInspectionConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("AccessDeniedException", errorCode):
return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
case strings.EqualFold("InternalServerException", errorCode):
return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
case strings.EqualFold("ThrottlingException", errorCode):
return awsRestjson1_deserializeErrorThrottlingException(response, errorBody)
case strings.EqualFold("ValidationException", errorCode):
return awsRestjson1_deserializeErrorValidationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsRestjson1_deserializeOpHttpBindingsInternalServerException(v *types.InternalServerException, response *smithyhttp.Response) error {
if v == nil {
return fmt.Errorf("unsupported deserialization for nil %T", v)
}
if headerValues := response.Header.Values("Retry-After"); len(headerValues) != 0 {
headerValues[0] = strings.TrimSpace(headerValues[0])
vv, err := strconv.ParseInt(headerValues[0], 0, 32)
if err != nil {
return err
}
v.RetryAfterSeconds = ptr.Int32(int32(vv))
}
return nil
}
func awsRestjson1_deserializeOpHttpBindingsThrottlingException(v *types.ThrottlingException, response *smithyhttp.Response) error {
if v == nil {
return fmt.Errorf("unsupported deserialization for nil %T", v)
}
if headerValues := response.Header.Values("Retry-After"); len(headerValues) != 0 {
headerValues[0] = strings.TrimSpace(headerValues[0])
vv, err := strconv.ParseInt(headerValues[0], 0, 32)
if err != nil {
return err
}
v.RetryAfterSeconds = ptr.Int32(int32(vv))
}
return nil
}
func awsRestjson1_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.AccessDeniedException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentAccessDeniedException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_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_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ConflictException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentConflictException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorInternalServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.InternalServerException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentInternalServerException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if err := awsRestjson1_deserializeOpHttpBindingsInternalServerException(output, response); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response error with invalid HTTP bindings, %w", err)}
}
return output
}
func awsRestjson1_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ResourceNotFoundException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentResourceNotFoundException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorServiceQuotaExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ServiceQuotaExceededException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentServiceQuotaExceededException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ThrottlingException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentThrottlingException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if err := awsRestjson1_deserializeOpHttpBindingsThrottlingException(output, response); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to decode response error with invalid HTTP bindings, %w", err)}
}
return output
}
func awsRestjson1_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
output := &types.ValidationException{}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
err := awsRestjson1_deserializeDocumentValidationException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsRestjson1_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AccessDeniedException
if *v == nil {
sv = &types.AccessDeniedException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAccount(v **types.Account, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Account
if *v == nil {
sv = &types.Account{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "resourceStatus":
if err := awsRestjson1_deserializeDocumentResourceStatus(&sv.ResourceStatus, value); err != nil {
return err
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Status to be of type string, got %T instead", value)
}
sv.Status = types.Status(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAccountAggregationResponse(v **types.AccountAggregationResponse, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AccountAggregationResponse
if *v == nil {
sv = &types.AccountAggregationResponse{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "severityCounts":
if err := awsRestjson1_deserializeDocumentSeverityCounts(&sv.SeverityCounts, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAccountList(v *[]types.Account, 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.Account
if *v == nil {
cv = []types.Account{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Account
destAddr := &col
if err := awsRestjson1_deserializeDocumentAccount(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentAccountState(v **types.AccountState, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AccountState
if *v == nil {
sv = &types.AccountState{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "resourceState":
if err := awsRestjson1_deserializeDocumentResourceState(&sv.ResourceState, value); err != nil {
return err
}
case "state":
if err := awsRestjson1_deserializeDocumentState(&sv.State, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAccountStateList(v *[]types.AccountState, 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.AccountState
if *v == nil {
cv = []types.AccountState{}
} else {
cv = *v
}
for _, value := range shape {
var col types.AccountState
destAddr := &col
if err := awsRestjson1_deserializeDocumentAccountState(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentAggregationResponse(v *types.AggregationResponse, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var uv types.AggregationResponse
loop:
for key, value := range shape {
if value == nil {
continue
}
switch key {
case "accountAggregation":
var mv types.AccountAggregationResponse
destAddr := &mv
if err := awsRestjson1_deserializeDocumentAccountAggregationResponse(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.AggregationResponseMemberAccountAggregation{Value: mv}
break loop
case "amiAggregation":
var mv types.AmiAggregationResponse
destAddr := &mv
if err := awsRestjson1_deserializeDocumentAmiAggregationResponse(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.AggregationResponseMemberAmiAggregation{Value: mv}
break loop
case "awsEcrContainerAggregation":
var mv types.AwsEcrContainerAggregationResponse
destAddr := &mv
if err := awsRestjson1_deserializeDocumentAwsEcrContainerAggregationResponse(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.AggregationResponseMemberAwsEcrContainerAggregation{Value: mv}
break loop
case "ec2InstanceAggregation":
var mv types.Ec2InstanceAggregationResponse
destAddr := &mv
if err := awsRestjson1_deserializeDocumentEc2InstanceAggregationResponse(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.AggregationResponseMemberEc2InstanceAggregation{Value: mv}
break loop
case "findingTypeAggregation":
var mv types.FindingTypeAggregationResponse
destAddr := &mv
if err := awsRestjson1_deserializeDocumentFindingTypeAggregationResponse(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.AggregationResponseMemberFindingTypeAggregation{Value: mv}
break loop
case "imageLayerAggregation":
var mv types.ImageLayerAggregationResponse
destAddr := &mv
if err := awsRestjson1_deserializeDocumentImageLayerAggregationResponse(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.AggregationResponseMemberImageLayerAggregation{Value: mv}
break loop
case "lambdaFunctionAggregation":
var mv types.LambdaFunctionAggregationResponse
destAddr := &mv
if err := awsRestjson1_deserializeDocumentLambdaFunctionAggregationResponse(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.AggregationResponseMemberLambdaFunctionAggregation{Value: mv}
break loop
case "lambdaLayerAggregation":
var mv types.LambdaLayerAggregationResponse
destAddr := &mv
if err := awsRestjson1_deserializeDocumentLambdaLayerAggregationResponse(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.AggregationResponseMemberLambdaLayerAggregation{Value: mv}
break loop
case "packageAggregation":
var mv types.PackageAggregationResponse
destAddr := &mv
if err := awsRestjson1_deserializeDocumentPackageAggregationResponse(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.AggregationResponseMemberPackageAggregation{Value: mv}
break loop
case "repositoryAggregation":
var mv types.RepositoryAggregationResponse
destAddr := &mv
if err := awsRestjson1_deserializeDocumentRepositoryAggregationResponse(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.AggregationResponseMemberRepositoryAggregation{Value: mv}
break loop
case "titleAggregation":
var mv types.TitleAggregationResponse
destAddr := &mv
if err := awsRestjson1_deserializeDocumentTitleAggregationResponse(&destAddr, value); err != nil {
return err
}
mv = *destAddr
uv = &types.AggregationResponseMemberTitleAggregation{Value: mv}
break loop
default:
uv = &types.UnknownUnionMember{Tag: key}
break loop
}
}
*v = uv
return nil
}
func awsRestjson1_deserializeDocumentAggregationResponseList(v *[]types.AggregationResponse, 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.AggregationResponse
if *v == nil {
cv = []types.AggregationResponse{}
} else {
cv = *v
}
for _, value := range shape {
var col types.AggregationResponse
if err := awsRestjson1_deserializeDocumentAggregationResponse(&col, value); err != nil {
return err
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentAmiAggregationResponse(v **types.AmiAggregationResponse, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AmiAggregationResponse
if *v == nil {
sv = &types.AmiAggregationResponse{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "affectedInstances":
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.AffectedInstances = ptr.Int64(i64)
}
case "ami":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AmiId to be of type string, got %T instead", value)
}
sv.Ami = ptr.String(jtv)
}
case "severityCounts":
if err := awsRestjson1_deserializeDocumentSeverityCounts(&sv.SeverityCounts, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentArchitectureList(v *[]types.Architecture, 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.Architecture
if *v == nil {
cv = []types.Architecture{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Architecture
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Architecture to be of type string, got %T instead", value)
}
col = types.Architecture(jtv)
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentAtigData(v **types.AtigData, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AtigData
if *v == nil {
sv = &types.AtigData{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "firstSeen":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.FirstSeen = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected FirstSeen to be a JSON Number, got %T instead", value)
}
}
case "lastSeen":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastSeen = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected LastSeen to be a JSON Number, got %T instead", value)
}
}
case "targets":
if err := awsRestjson1_deserializeDocumentTargets(&sv.Targets, value); err != nil {
return err
}
case "ttps":
if err := awsRestjson1_deserializeDocumentTtps(&sv.Ttps, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAutoEnable(v **types.AutoEnable, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AutoEnable
if *v == nil {
sv = &types.AutoEnable{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ec2":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.Ec2 = ptr.Bool(jtv)
}
case "ecr":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.Ecr = ptr.Bool(jtv)
}
case "lambda":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.Lambda = ptr.Bool(jtv)
}
case "lambdaCode":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.LambdaCode = ptr.Bool(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAwsEc2InstanceDetails(v **types.AwsEc2InstanceDetails, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AwsEc2InstanceDetails
if *v == nil {
sv = &types.AwsEc2InstanceDetails{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "iamInstanceProfileArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.IamInstanceProfileArn = ptr.String(jtv)
}
case "imageId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.ImageId = ptr.String(jtv)
}
case "ipV4Addresses":
if err := awsRestjson1_deserializeDocumentIpV4AddressList(&sv.IpV4Addresses, value); err != nil {
return err
}
case "ipV6Addresses":
if err := awsRestjson1_deserializeDocumentIpV6AddressList(&sv.IpV6Addresses, value); err != nil {
return err
}
case "keyName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.KeyName = ptr.String(jtv)
}
case "launchedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LaunchedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected DateTimeTimestamp to be a JSON Number, got %T instead", value)
}
}
case "platform":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Platform to be of type string, got %T instead", value)
}
sv.Platform = ptr.String(jtv)
}
case "subnetId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.SubnetId = ptr.String(jtv)
}
case "type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.Type = ptr.String(jtv)
}
case "vpcId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.VpcId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAwsEcrContainerAggregationResponse(v **types.AwsEcrContainerAggregationResponse, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AwsEcrContainerAggregationResponse
if *v == nil {
sv = &types.AwsEcrContainerAggregationResponse{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "architecture":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Architecture = ptr.String(jtv)
}
case "imageSha":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ImageSha = ptr.String(jtv)
}
case "imageTags":
if err := awsRestjson1_deserializeDocumentStringList(&sv.ImageTags, value); err != nil {
return err
}
case "repository":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Repository = ptr.String(jtv)
}
case "resourceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.ResourceId = ptr.String(jtv)
}
case "severityCounts":
if err := awsRestjson1_deserializeDocumentSeverityCounts(&sv.SeverityCounts, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAwsEcrContainerImageDetails(v **types.AwsEcrContainerImageDetails, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AwsEcrContainerImageDetails
if *v == nil {
sv = &types.AwsEcrContainerImageDetails{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "architecture":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.Architecture = ptr.String(jtv)
}
case "author":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Author = ptr.String(jtv)
}
case "imageHash":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ImageHash to be of type string, got %T instead", value)
}
sv.ImageHash = ptr.String(jtv)
}
case "imageTags":
if err := awsRestjson1_deserializeDocumentImageTagList(&sv.ImageTags, value); err != nil {
return err
}
case "platform":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Platform to be of type string, got %T instead", value)
}
sv.Platform = ptr.String(jtv)
}
case "pushedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.PushedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected DateTimeTimestamp to be a JSON Number, got %T instead", value)
}
}
case "registry":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.Registry = ptr.String(jtv)
}
case "repositoryName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.RepositoryName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentAwsLambdaFunctionDetails(v **types.AwsLambdaFunctionDetails, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AwsLambdaFunctionDetails
if *v == nil {
sv = &types.AwsLambdaFunctionDetails{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "architectures":
if err := awsRestjson1_deserializeDocumentArchitectureList(&sv.Architectures, value); err != nil {
return err
}
case "codeSha256":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.CodeSha256 = ptr.String(jtv)
}
case "executionRoleArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ExecutionRoleArn to be of type string, got %T instead", value)
}
sv.ExecutionRoleArn = ptr.String(jtv)
}
case "functionName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FunctionName to be of type string, got %T instead", value)
}
sv.FunctionName = ptr.String(jtv)
}
case "lastModifiedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "layers":
if err := awsRestjson1_deserializeDocumentLayerList(&sv.Layers, value); err != nil {
return err
}
case "packageType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PackageType to be of type string, got %T instead", value)
}
sv.PackageType = types.PackageType(jtv)
}
case "runtime":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Runtime to be of type string, got %T instead", value)
}
sv.Runtime = types.Runtime(jtv)
}
case "version":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Version to be of type string, got %T instead", value)
}
sv.Version = ptr.String(jtv)
}
case "vpcConfig":
if err := awsRestjson1_deserializeDocumentLambdaVpcConfig(&sv.VpcConfig, value); err != nil {
return err
}
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_deserializeDocumentCisaData(v **types.CisaData, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.CisaData
if *v == nil {
sv = &types.CisaData{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "action":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CisaAction to be of type string, got %T instead", value)
}
sv.Action = ptr.String(jtv)
}
case "dateAdded":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.DateAdded = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected CisaDateAdded to be a JSON Number, got %T instead", value)
}
}
case "dateDue":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.DateDue = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected CisaDateDue to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentCodeFilePath(v **types.CodeFilePath, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.CodeFilePath
if *v == nil {
sv = &types.CodeFilePath{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "endLine":
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.EndLine = ptr.Int32(int32(i64))
}
case "fileName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.FileName = ptr.String(jtv)
}
case "filePath":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.FilePath = ptr.String(jtv)
}
case "startLine":
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.StartLine = ptr.Int32(int32(i64))
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentCodeLine(v **types.CodeLine, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.CodeLine
if *v == nil {
sv = &types.CodeLine{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "content":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Content = ptr.String(jtv)
}
case "lineNumber":
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.LineNumber = ptr.Int32(int32(i64))
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentCodeLineList(v *[]types.CodeLine, 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.CodeLine
if *v == nil {
cv = []types.CodeLine{}
} else {
cv = *v
}
for _, value := range shape {
var col types.CodeLine
destAddr := &col
if err := awsRestjson1_deserializeDocumentCodeLine(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentCodeSnippetError(v **types.CodeSnippetError, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.CodeSnippetError
if *v == nil {
sv = &types.CodeSnippetError{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "errorCode":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CodeSnippetErrorCode to be of type string, got %T instead", value)
}
sv.ErrorCode = types.CodeSnippetErrorCode(jtv)
}
case "errorMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.ErrorMessage = ptr.String(jtv)
}
case "findingArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FindingArn to be of type string, got %T instead", value)
}
sv.FindingArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentCodeSnippetErrorList(v *[]types.CodeSnippetError, 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.CodeSnippetError
if *v == nil {
cv = []types.CodeSnippetError{}
} else {
cv = *v
}
for _, value := range shape {
var col types.CodeSnippetError
destAddr := &col
if err := awsRestjson1_deserializeDocumentCodeSnippetError(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentCodeSnippetResult(v **types.CodeSnippetResult, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.CodeSnippetResult
if *v == nil {
sv = &types.CodeSnippetResult{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "codeSnippet":
if err := awsRestjson1_deserializeDocumentCodeLineList(&sv.CodeSnippet, value); err != nil {
return err
}
case "endLine":
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.EndLine = ptr.Int32(int32(i64))
}
case "findingArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FindingArn to be of type string, got %T instead", value)
}
sv.FindingArn = ptr.String(jtv)
}
case "startLine":
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.StartLine = ptr.Int32(int32(i64))
}
case "suggestedFixes":
if err := awsRestjson1_deserializeDocumentSuggestedFixes(&sv.SuggestedFixes, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentCodeSnippetResultList(v *[]types.CodeSnippetResult, 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.CodeSnippetResult
if *v == nil {
cv = []types.CodeSnippetResult{}
} else {
cv = *v
}
for _, value := range shape {
var col types.CodeSnippetResult
destAddr := &col
if err := awsRestjson1_deserializeDocumentCodeSnippetResult(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentCodeVulnerabilityDetails(v **types.CodeVulnerabilityDetails, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.CodeVulnerabilityDetails
if *v == nil {
sv = &types.CodeVulnerabilityDetails{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "cwes":
if err := awsRestjson1_deserializeDocumentCweList(&sv.Cwes, value); err != nil {
return err
}
case "detectorId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.DetectorId = ptr.String(jtv)
}
case "detectorName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.DetectorName = ptr.String(jtv)
}
case "detectorTags":
if err := awsRestjson1_deserializeDocumentDetectorTagList(&sv.DetectorTags, value); err != nil {
return err
}
case "filePath":
if err := awsRestjson1_deserializeDocumentCodeFilePath(&sv.FilePath, value); err != nil {
return err
}
case "referenceUrls":
if err := awsRestjson1_deserializeDocumentReferenceUrls(&sv.ReferenceUrls, value); err != nil {
return err
}
case "ruleId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.RuleId = ptr.String(jtv)
}
case "sourceLambdaLayerArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LambdaLayerArn to be of type string, got %T instead", value)
}
sv.SourceLambdaLayerArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ConflictException
if *v == nil {
sv = &types.ConflictException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
case "resourceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ResourceId = ptr.String(jtv)
}
case "resourceType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ResourceType = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentCounts(v **types.Counts, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Counts
if *v == nil {
sv = &types.Counts{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "count":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected AggCounts to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Count = i64
}
case "groupKey":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected GroupKey to be of type string, got %T instead", value)
}
sv.GroupKey = types.GroupKey(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentCountsList(v *[]types.Counts, 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.Counts
if *v == nil {
cv = []types.Counts{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Counts
destAddr := &col
if err := awsRestjson1_deserializeDocumentCounts(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentCoveredResource(v **types.CoveredResource, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.CoveredResource
if *v == nil {
sv = &types.CoveredResource{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "lastScannedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastScannedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected DateTimeTimestamp to be a JSON Number, got %T instead", value)
}
}
case "resourceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.ResourceId = ptr.String(jtv)
}
case "resourceMetadata":
if err := awsRestjson1_deserializeDocumentResourceScanMetadata(&sv.ResourceMetadata, value); err != nil {
return err
}
case "resourceType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CoverageResourceType to be of type string, got %T instead", value)
}
sv.ResourceType = types.CoverageResourceType(jtv)
}
case "scanStatus":
if err := awsRestjson1_deserializeDocumentScanStatus(&sv.ScanStatus, value); err != nil {
return err
}
case "scanType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ScanType to be of type string, got %T instead", value)
}
sv.ScanType = types.ScanType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentCoveredResources(v *[]types.CoveredResource, 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.CoveredResource
if *v == nil {
cv = []types.CoveredResource{}
} else {
cv = *v
}
for _, value := range shape {
var col types.CoveredResource
destAddr := &col
if err := awsRestjson1_deserializeDocumentCoveredResource(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentCvss2(v **types.Cvss2, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Cvss2
if *v == nil {
sv = &types.Cvss2{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "baseScore":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.BaseScore = 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.BaseScore = f64
default:
return fmt.Errorf("expected Cvss2BaseScore to be a JSON Number, got %T instead", value)
}
}
case "scoringVector":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Cvss2ScoringVector to be of type string, got %T instead", value)
}
sv.ScoringVector = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentCvss3(v **types.Cvss3, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Cvss3
if *v == nil {
sv = &types.Cvss3{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "baseScore":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.BaseScore = 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.BaseScore = f64
default:
return fmt.Errorf("expected Cvss3BaseScore to be a JSON Number, got %T instead", value)
}
}
case "scoringVector":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Cvss3ScoringVector to be of type string, got %T instead", value)
}
sv.ScoringVector = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentCvssScore(v **types.CvssScore, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.CvssScore
if *v == nil {
sv = &types.CvssScore{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "baseScore":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.BaseScore = ptr.Float64(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.BaseScore = ptr.Float64(f64)
default:
return fmt.Errorf("expected Double to be a JSON Number, got %T instead", value)
}
}
case "scoringVector":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.ScoringVector = ptr.String(jtv)
}
case "source":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.Source = ptr.String(jtv)
}
case "version":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.Version = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentCvssScoreAdjustment(v **types.CvssScoreAdjustment, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.CvssScoreAdjustment
if *v == nil {
sv = &types.CvssScoreAdjustment{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "metric":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.Metric = ptr.String(jtv)
}
case "reason":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.Reason = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentCvssScoreAdjustmentList(v *[]types.CvssScoreAdjustment, 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.CvssScoreAdjustment
if *v == nil {
cv = []types.CvssScoreAdjustment{}
} else {
cv = *v
}
for _, value := range shape {
var col types.CvssScoreAdjustment
destAddr := &col
if err := awsRestjson1_deserializeDocumentCvssScoreAdjustment(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentCvssScoreDetails(v **types.CvssScoreDetails, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.CvssScoreDetails
if *v == nil {
sv = &types.CvssScoreDetails{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "adjustments":
if err := awsRestjson1_deserializeDocumentCvssScoreAdjustmentList(&sv.Adjustments, value); err != nil {
return err
}
case "cvssSource":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.CvssSource = ptr.String(jtv)
}
case "score":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.Score = ptr.Float64(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.Score = ptr.Float64(f64)
default:
return fmt.Errorf("expected Double to be a JSON Number, got %T instead", value)
}
}
case "scoreSource":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.ScoreSource = ptr.String(jtv)
}
case "scoringVector":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.ScoringVector = ptr.String(jtv)
}
case "version":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.Version = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentCvssScoreList(v *[]types.CvssScore, 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.CvssScore
if *v == nil {
cv = []types.CvssScore{}
} else {
cv = *v
}
for _, value := range shape {
var col types.CvssScore
destAddr := &col
if err := awsRestjson1_deserializeDocumentCvssScore(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentCweList(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 NonEmptyString to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentCwes(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 Cwe to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentDateFilter(v **types.DateFilter, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.DateFilter
if *v == nil {
sv = &types.DateFilter{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "endInclusive":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.EndInclusive = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "startInclusive":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.StartInclusive = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDateFilterList(v *[]types.DateFilter, 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.DateFilter
if *v == nil {
cv = []types.DateFilter{}
} else {
cv = *v
}
for _, value := range shape {
var col types.DateFilter
destAddr := &col
if err := awsRestjson1_deserializeDocumentDateFilter(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentDelegatedAdmin(v **types.DelegatedAdmin, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.DelegatedAdmin
if *v == nil {
sv = &types.DelegatedAdmin{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "relationshipStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected RelationshipStatus to be of type string, got %T instead", value)
}
sv.RelationshipStatus = types.RelationshipStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDelegatedAdminAccount(v **types.DelegatedAdminAccount, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.DelegatedAdminAccount
if *v == nil {
sv = &types.DelegatedAdminAccount{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DelegatedAdminStatus to be of type string, got %T instead", value)
}
sv.Status = types.DelegatedAdminStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDelegatedAdminAccountList(v *[]types.DelegatedAdminAccount, 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.DelegatedAdminAccount
if *v == nil {
cv = []types.DelegatedAdminAccount{}
} else {
cv = *v
}
for _, value := range shape {
var col types.DelegatedAdminAccount
destAddr := &col
if err := awsRestjson1_deserializeDocumentDelegatedAdminAccount(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentDestination(v **types.Destination, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Destination
if *v == nil {
sv = &types.Destination{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "bucketName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.BucketName = ptr.String(jtv)
}
case "keyPrefix":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.KeyPrefix = ptr.String(jtv)
}
case "kmsKeyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.KmsKeyArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentDetectionPlatforms(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 NonEmptyString to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentDetectorTagList(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 NonEmptyString to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentEc2InstanceAggregationResponse(v **types.Ec2InstanceAggregationResponse, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Ec2InstanceAggregationResponse
if *v == nil {
sv = &types.Ec2InstanceAggregationResponse{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "ami":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AmiId to be of type string, got %T instead", value)
}
sv.Ami = ptr.String(jtv)
}
case "instanceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.InstanceId = ptr.String(jtv)
}
case "instanceTags":
if err := awsRestjson1_deserializeDocumentTagMap(&sv.InstanceTags, value); err != nil {
return err
}
case "networkFindings":
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.NetworkFindings = ptr.Int64(i64)
}
case "operatingSystem":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.OperatingSystem = ptr.String(jtv)
}
case "severityCounts":
if err := awsRestjson1_deserializeDocumentSeverityCounts(&sv.SeverityCounts, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentEc2Metadata(v **types.Ec2Metadata, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Ec2Metadata
if *v == nil {
sv = &types.Ec2Metadata{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "amiId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AmiId to be of type string, got %T instead", value)
}
sv.AmiId = ptr.String(jtv)
}
case "platform":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Ec2Platform to be of type string, got %T instead", value)
}
sv.Platform = types.Ec2Platform(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentEcrConfigurationState(v **types.EcrConfigurationState, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.EcrConfigurationState
if *v == nil {
sv = &types.EcrConfigurationState{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "rescanDurationState":
if err := awsRestjson1_deserializeDocumentEcrRescanDurationState(&sv.RescanDurationState, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentEcrContainerImageMetadata(v **types.EcrContainerImageMetadata, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.EcrContainerImageMetadata
if *v == nil {
sv = &types.EcrContainerImageMetadata{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "tags":
if err := awsRestjson1_deserializeDocumentTagList(&sv.Tags, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentEcrRepositoryMetadata(v **types.EcrRepositoryMetadata, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.EcrRepositoryMetadata
if *v == nil {
sv = &types.EcrRepositoryMetadata{}
} 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 "scanFrequency":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EcrScanFrequency to be of type string, got %T instead", value)
}
sv.ScanFrequency = types.EcrScanFrequency(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentEcrRescanDurationState(v **types.EcrRescanDurationState, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.EcrRescanDurationState
if *v == nil {
sv = &types.EcrRescanDurationState{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "rescanDuration":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EcrRescanDuration to be of type string, got %T instead", value)
}
sv.RescanDuration = types.EcrRescanDuration(jtv)
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected EcrRescanDurationStatus to be of type string, got %T instead", value)
}
sv.Status = types.EcrRescanDurationStatus(jtv)
}
case "updatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.UpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected DateTimeTimestamp to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentEpss(v **types.Epss, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Epss
if *v == nil {
sv = &types.Epss{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "score":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.Score = 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.Score = f64
default:
return fmt.Errorf("expected EpssScore to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentEpssDetails(v **types.EpssDetails, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.EpssDetails
if *v == nil {
sv = &types.EpssDetails{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "score":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.Score = 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.Score = f64
default:
return fmt.Errorf("expected EpssScoreValue to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentExploitabilityDetails(v **types.ExploitabilityDetails, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ExploitabilityDetails
if *v == nil {
sv = &types.ExploitabilityDetails{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "lastKnownExploitAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastKnownExploitAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected DateTimeTimestamp to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentExploitObserved(v **types.ExploitObserved, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ExploitObserved
if *v == nil {
sv = &types.ExploitObserved{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "firstSeen":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.FirstSeen = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected FirstSeen to be a JSON Number, got %T instead", value)
}
}
case "lastSeen":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastSeen = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected LastSeen to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentFailedAccount(v **types.FailedAccount, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.FailedAccount
if *v == nil {
sv = &types.FailedAccount{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "errorCode":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorCode to be of type string, got %T instead", value)
}
sv.ErrorCode = types.ErrorCode(jtv)
}
case "errorMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.ErrorMessage = ptr.String(jtv)
}
case "resourceStatus":
if err := awsRestjson1_deserializeDocumentResourceStatus(&sv.ResourceStatus, value); err != nil {
return err
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Status to be of type string, got %T instead", value)
}
sv.Status = types.Status(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentFailedAccountList(v *[]types.FailedAccount, 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.FailedAccount
if *v == nil {
cv = []types.FailedAccount{}
} else {
cv = *v
}
for _, value := range shape {
var col types.FailedAccount
destAddr := &col
if err := awsRestjson1_deserializeDocumentFailedAccount(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentFailedMemberAccountEc2DeepInspectionStatusState(v **types.FailedMemberAccountEc2DeepInspectionStatusState, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.FailedMemberAccountEc2DeepInspectionStatusState
if *v == nil {
sv = &types.FailedMemberAccountEc2DeepInspectionStatusState{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "ec2ScanStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Status to be of type string, got %T instead", value)
}
sv.Ec2ScanStatus = types.Status(jtv)
}
case "errorMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.ErrorMessage = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentFailedMemberAccountEc2DeepInspectionStatusStateList(v *[]types.FailedMemberAccountEc2DeepInspectionStatusState, 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.FailedMemberAccountEc2DeepInspectionStatusState
if *v == nil {
cv = []types.FailedMemberAccountEc2DeepInspectionStatusState{}
} else {
cv = *v
}
for _, value := range shape {
var col types.FailedMemberAccountEc2DeepInspectionStatusState
destAddr := &col
if err := awsRestjson1_deserializeDocumentFailedMemberAccountEc2DeepInspectionStatusState(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentFilter(v **types.Filter, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Filter
if *v == nil {
sv = &types.Filter{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "action":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FilterAction to be of type string, got %T instead", value)
}
sv.Action = types.FilterAction(jtv)
}
case "arn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FilterArn to be of type string, got %T instead", value)
}
sv.Arn = ptr.String(jtv)
}
case "createdAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected DateTimeTimestamp to be a JSON Number, got %T instead", value)
}
}
case "criteria":
if err := awsRestjson1_deserializeDocumentFilterCriteria(&sv.Criteria, value); err != nil {
return err
}
case "description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FilterDescription 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 FilterName to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "ownerId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected OwnerId to be of type string, got %T instead", value)
}
sv.OwnerId = ptr.String(jtv)
}
case "reason":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FilterReason to be of type string, got %T instead", value)
}
sv.Reason = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil {
return err
}
case "updatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.UpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected DateTimeTimestamp to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentFilterCriteria(v **types.FilterCriteria, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.FilterCriteria
if *v == nil {
sv = &types.FilterCriteria{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "awsAccountId":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.AwsAccountId, value); err != nil {
return err
}
case "codeVulnerabilityDetectorName":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.CodeVulnerabilityDetectorName, value); err != nil {
return err
}
case "codeVulnerabilityDetectorTags":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.CodeVulnerabilityDetectorTags, value); err != nil {
return err
}
case "codeVulnerabilityFilePath":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.CodeVulnerabilityFilePath, value); err != nil {
return err
}
case "componentId":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.ComponentId, value); err != nil {
return err
}
case "componentType":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.ComponentType, value); err != nil {
return err
}
case "ec2InstanceImageId":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.Ec2InstanceImageId, value); err != nil {
return err
}
case "ec2InstanceSubnetId":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.Ec2InstanceSubnetId, value); err != nil {
return err
}
case "ec2InstanceVpcId":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.Ec2InstanceVpcId, value); err != nil {
return err
}
case "ecrImageArchitecture":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.EcrImageArchitecture, value); err != nil {
return err
}
case "ecrImageHash":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.EcrImageHash, value); err != nil {
return err
}
case "ecrImagePushedAt":
if err := awsRestjson1_deserializeDocumentDateFilterList(&sv.EcrImagePushedAt, value); err != nil {
return err
}
case "ecrImageRegistry":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.EcrImageRegistry, value); err != nil {
return err
}
case "ecrImageRepositoryName":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.EcrImageRepositoryName, value); err != nil {
return err
}
case "ecrImageTags":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.EcrImageTags, value); err != nil {
return err
}
case "epssScore":
if err := awsRestjson1_deserializeDocumentNumberFilterList(&sv.EpssScore, value); err != nil {
return err
}
case "exploitAvailable":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.ExploitAvailable, value); err != nil {
return err
}
case "findingArn":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.FindingArn, value); err != nil {
return err
}
case "findingStatus":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.FindingStatus, value); err != nil {
return err
}
case "findingType":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.FindingType, value); err != nil {
return err
}
case "firstObservedAt":
if err := awsRestjson1_deserializeDocumentDateFilterList(&sv.FirstObservedAt, value); err != nil {
return err
}
case "fixAvailable":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.FixAvailable, value); err != nil {
return err
}
case "inspectorScore":
if err := awsRestjson1_deserializeDocumentNumberFilterList(&sv.InspectorScore, value); err != nil {
return err
}
case "lambdaFunctionExecutionRoleArn":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.LambdaFunctionExecutionRoleArn, value); err != nil {
return err
}
case "lambdaFunctionLastModifiedAt":
if err := awsRestjson1_deserializeDocumentDateFilterList(&sv.LambdaFunctionLastModifiedAt, value); err != nil {
return err
}
case "lambdaFunctionLayers":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.LambdaFunctionLayers, value); err != nil {
return err
}
case "lambdaFunctionName":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.LambdaFunctionName, value); err != nil {
return err
}
case "lambdaFunctionRuntime":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.LambdaFunctionRuntime, value); err != nil {
return err
}
case "lastObservedAt":
if err := awsRestjson1_deserializeDocumentDateFilterList(&sv.LastObservedAt, value); err != nil {
return err
}
case "networkProtocol":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.NetworkProtocol, value); err != nil {
return err
}
case "portRange":
if err := awsRestjson1_deserializeDocumentPortRangeFilterList(&sv.PortRange, value); err != nil {
return err
}
case "relatedVulnerabilities":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.RelatedVulnerabilities, value); err != nil {
return err
}
case "resourceId":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.ResourceId, value); err != nil {
return err
}
case "resourceTags":
if err := awsRestjson1_deserializeDocumentMapFilterList(&sv.ResourceTags, value); err != nil {
return err
}
case "resourceType":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.ResourceType, value); err != nil {
return err
}
case "severity":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.Severity, value); err != nil {
return err
}
case "title":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.Title, value); err != nil {
return err
}
case "updatedAt":
if err := awsRestjson1_deserializeDocumentDateFilterList(&sv.UpdatedAt, value); err != nil {
return err
}
case "vendorSeverity":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.VendorSeverity, value); err != nil {
return err
}
case "vulnerabilityId":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.VulnerabilityId, value); err != nil {
return err
}
case "vulnerabilitySource":
if err := awsRestjson1_deserializeDocumentStringFilterList(&sv.VulnerabilitySource, value); err != nil {
return err
}
case "vulnerablePackages":
if err := awsRestjson1_deserializeDocumentPackageFilterList(&sv.VulnerablePackages, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentFilterList(v *[]types.Filter, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.Filter
if *v == nil {
cv = []types.Filter{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Filter
destAddr := &col
if err := awsRestjson1_deserializeDocumentFilter(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentFinding(v **types.Finding, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Finding
if *v == nil {
sv = &types.Finding{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "awsAccountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AwsAccountId = ptr.String(jtv)
}
case "codeVulnerabilityDetails":
if err := awsRestjson1_deserializeDocumentCodeVulnerabilityDetails(&sv.CodeVulnerabilityDetails, value); err != nil {
return err
}
case "description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FindingDescription to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "epss":
if err := awsRestjson1_deserializeDocumentEpssDetails(&sv.Epss, value); err != nil {
return err
}
case "exploitabilityDetails":
if err := awsRestjson1_deserializeDocumentExploitabilityDetails(&sv.ExploitabilityDetails, value); err != nil {
return err
}
case "exploitAvailable":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ExploitAvailable to be of type string, got %T instead", value)
}
sv.ExploitAvailable = types.ExploitAvailable(jtv)
}
case "findingArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FindingArn to be of type string, got %T instead", value)
}
sv.FindingArn = ptr.String(jtv)
}
case "firstObservedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.FirstObservedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected DateTimeTimestamp to be a JSON Number, got %T instead", value)
}
}
case "fixAvailable":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FixAvailable to be of type string, got %T instead", value)
}
sv.FixAvailable = types.FixAvailable(jtv)
}
case "inspectorScore":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.InspectorScore = ptr.Float64(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.InspectorScore = ptr.Float64(f64)
default:
return fmt.Errorf("expected Double to be a JSON Number, got %T instead", value)
}
}
case "inspectorScoreDetails":
if err := awsRestjson1_deserializeDocumentInspectorScoreDetails(&sv.InspectorScoreDetails, value); err != nil {
return err
}
case "lastObservedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastObservedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected DateTimeTimestamp to be a JSON Number, got %T instead", value)
}
}
case "networkReachabilityDetails":
if err := awsRestjson1_deserializeDocumentNetworkReachabilityDetails(&sv.NetworkReachabilityDetails, value); err != nil {
return err
}
case "packageVulnerabilityDetails":
if err := awsRestjson1_deserializeDocumentPackageVulnerabilityDetails(&sv.PackageVulnerabilityDetails, value); err != nil {
return err
}
case "remediation":
if err := awsRestjson1_deserializeDocumentRemediation(&sv.Remediation, value); err != nil {
return err
}
case "resources":
if err := awsRestjson1_deserializeDocumentResourceList(&sv.Resources, value); err != nil {
return err
}
case "severity":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Severity to be of type string, got %T instead", value)
}
sv.Severity = types.Severity(jtv)
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FindingStatus to be of type string, got %T instead", value)
}
sv.Status = types.FindingStatus(jtv)
}
case "title":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FindingTitle to be of type string, got %T instead", value)
}
sv.Title = ptr.String(jtv)
}
case "type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FindingType to be of type string, got %T instead", value)
}
sv.Type = types.FindingType(jtv)
}
case "updatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.UpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected DateTimeTimestamp to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentFindingList(v *[]types.Finding, 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.Finding
if *v == nil {
cv = []types.Finding{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Finding
destAddr := &col
if err := awsRestjson1_deserializeDocumentFinding(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentFindingTypeAggregationResponse(v **types.FindingTypeAggregationResponse, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.FindingTypeAggregationResponse
if *v == nil {
sv = &types.FindingTypeAggregationResponse{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "severityCounts":
if err := awsRestjson1_deserializeDocumentSeverityCounts(&sv.SeverityCounts, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentFreeTrialAccountInfo(v **types.FreeTrialAccountInfo, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.FreeTrialAccountInfo
if *v == nil {
sv = &types.FreeTrialAccountInfo{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MeteringAccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "freeTrialInfo":
if err := awsRestjson1_deserializeDocumentFreeTrialInfoList(&sv.FreeTrialInfo, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentFreeTrialAccountInfoList(v *[]types.FreeTrialAccountInfo, 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.FreeTrialAccountInfo
if *v == nil {
cv = []types.FreeTrialAccountInfo{}
} else {
cv = *v
}
for _, value := range shape {
var col types.FreeTrialAccountInfo
destAddr := &col
if err := awsRestjson1_deserializeDocumentFreeTrialAccountInfo(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentFreeTrialInfo(v **types.FreeTrialInfo, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.FreeTrialInfo
if *v == nil {
sv = &types.FreeTrialInfo{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "end":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.End = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "start":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.Start = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value)
}
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FreeTrialStatus to be of type string, got %T instead", value)
}
sv.Status = types.FreeTrialStatus(jtv)
}
case "type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FreeTrialType to be of type string, got %T instead", value)
}
sv.Type = types.FreeTrialType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentFreeTrialInfoError(v **types.FreeTrialInfoError, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.FreeTrialInfoError
if *v == nil {
sv = &types.FreeTrialInfoError{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MeteringAccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "code":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FreeTrialInfoErrorCode to be of type string, got %T instead", value)
}
sv.Code = types.FreeTrialInfoErrorCode(jtv)
}
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_deserializeDocumentFreeTrialInfoErrorList(v *[]types.FreeTrialInfoError, 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.FreeTrialInfoError
if *v == nil {
cv = []types.FreeTrialInfoError{}
} else {
cv = *v
}
for _, value := range shape {
var col types.FreeTrialInfoError
destAddr := &col
if err := awsRestjson1_deserializeDocumentFreeTrialInfoError(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentFreeTrialInfoList(v *[]types.FreeTrialInfo, 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.FreeTrialInfo
if *v == nil {
cv = []types.FreeTrialInfo{}
} else {
cv = *v
}
for _, value := range shape {
var col types.FreeTrialInfo
destAddr := &col
if err := awsRestjson1_deserializeDocumentFreeTrialInfo(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentImageLayerAggregationResponse(v **types.ImageLayerAggregationResponse, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ImageLayerAggregationResponse
if *v == nil {
sv = &types.ImageLayerAggregationResponse{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "layerHash":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.LayerHash = ptr.String(jtv)
}
case "repository":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.Repository = ptr.String(jtv)
}
case "resourceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.ResourceId = ptr.String(jtv)
}
case "severityCounts":
if err := awsRestjson1_deserializeDocumentSeverityCounts(&sv.SeverityCounts, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentImageTagList(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 NonEmptyString to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentInspectorScoreDetails(v **types.InspectorScoreDetails, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.InspectorScoreDetails
if *v == nil {
sv = &types.InspectorScoreDetails{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "adjustedCvss":
if err := awsRestjson1_deserializeDocumentCvssScoreDetails(&sv.AdjustedCvss, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentInternalServerException(v **types.InternalServerException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.InternalServerException
if *v == nil {
sv = &types.InternalServerException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
case "retryAfterSeconds":
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.RetryAfterSeconds = ptr.Int32(int32(i64))
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentIpV4AddressList(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 IpV4Address to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentIpV6AddressList(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 IpV6Address to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentLambdaFunctionAggregationResponse(v **types.LambdaFunctionAggregationResponse, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.LambdaFunctionAggregationResponse
if *v == nil {
sv = &types.LambdaFunctionAggregationResponse{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "functionName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.FunctionName = ptr.String(jtv)
}
case "lambdaTags":
if err := awsRestjson1_deserializeDocumentTagMap(&sv.LambdaTags, value); err != nil {
return err
}
case "lastModifiedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastModifiedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected DateTimeTimestamp to be a JSON Number, got %T instead", value)
}
}
case "resourceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.ResourceId = ptr.String(jtv)
}
case "runtime":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Runtime = ptr.String(jtv)
}
case "severityCounts":
if err := awsRestjson1_deserializeDocumentSeverityCounts(&sv.SeverityCounts, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentLambdaFunctionMetadata(v **types.LambdaFunctionMetadata, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.LambdaFunctionMetadata
if *v == nil {
sv = &types.LambdaFunctionMetadata{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "functionName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.FunctionName = ptr.String(jtv)
}
case "functionTags":
if err := awsRestjson1_deserializeDocumentTagMap(&sv.FunctionTags, value); err != nil {
return err
}
case "layers":
if err := awsRestjson1_deserializeDocumentLambdaLayerList(&sv.Layers, value); err != nil {
return err
}
case "runtime":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Runtime to be of type string, got %T instead", value)
}
sv.Runtime = types.Runtime(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentLambdaLayerAggregationResponse(v **types.LambdaLayerAggregationResponse, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.LambdaLayerAggregationResponse
if *v == nil {
sv = &types.LambdaLayerAggregationResponse{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "functionName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.FunctionName = ptr.String(jtv)
}
case "layerArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.LayerArn = ptr.String(jtv)
}
case "resourceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.ResourceId = ptr.String(jtv)
}
case "severityCounts":
if err := awsRestjson1_deserializeDocumentSeverityCounts(&sv.SeverityCounts, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentLambdaLayerList(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_deserializeDocumentLambdaVpcConfig(v **types.LambdaVpcConfig, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.LambdaVpcConfig
if *v == nil {
sv = &types.LambdaVpcConfig{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "securityGroupIds":
if err := awsRestjson1_deserializeDocumentSecurityGroupIdList(&sv.SecurityGroupIds, value); err != nil {
return err
}
case "subnetIds":
if err := awsRestjson1_deserializeDocumentSubnetIdList(&sv.SubnetIds, value); err != nil {
return err
}
case "vpcId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VpcId to be of type string, got %T instead", value)
}
sv.VpcId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentLayerList(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 LambdaLayerArn to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentMapFilter(v **types.MapFilter, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.MapFilter
if *v == nil {
sv = &types.MapFilter{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "comparison":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MapComparison to be of type string, got %T instead", value)
}
sv.Comparison = types.MapComparison(jtv)
}
case "key":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MapKey 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 MapValue to be of type string, got %T instead", value)
}
sv.Value = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentMapFilterList(v *[]types.MapFilter, 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.MapFilter
if *v == nil {
cv = []types.MapFilter{}
} else {
cv = *v
}
for _, value := range shape {
var col types.MapFilter
destAddr := &col
if err := awsRestjson1_deserializeDocumentMapFilter(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentMember(v **types.Member, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Member
if *v == nil {
sv = &types.Member{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "delegatedAdminAccountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.DelegatedAdminAccountId = ptr.String(jtv)
}
case "relationshipStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected RelationshipStatus to be of type string, got %T instead", value)
}
sv.RelationshipStatus = types.RelationshipStatus(jtv)
}
case "updatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.UpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected DateTimeTimestamp to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentMemberAccountEc2DeepInspectionStatusState(v **types.MemberAccountEc2DeepInspectionStatusState, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.MemberAccountEc2DeepInspectionStatusState
if *v == nil {
sv = &types.MemberAccountEc2DeepInspectionStatusState{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "errorMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.ErrorMessage = ptr.String(jtv)
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Ec2DeepInspectionStatus to be of type string, got %T instead", value)
}
sv.Status = types.Ec2DeepInspectionStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentMemberAccountEc2DeepInspectionStatusStateList(v *[]types.MemberAccountEc2DeepInspectionStatusState, 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.MemberAccountEc2DeepInspectionStatusState
if *v == nil {
cv = []types.MemberAccountEc2DeepInspectionStatusState{}
} else {
cv = *v
}
for _, value := range shape {
var col types.MemberAccountEc2DeepInspectionStatusState
destAddr := &col
if err := awsRestjson1_deserializeDocumentMemberAccountEc2DeepInspectionStatusState(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentMemberList(v *[]types.Member, 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.Member
if *v == nil {
cv = []types.Member{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Member
destAddr := &col
if err := awsRestjson1_deserializeDocumentMember(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentNetworkPath(v **types.NetworkPath, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.NetworkPath
if *v == nil {
sv = &types.NetworkPath{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "steps":
if err := awsRestjson1_deserializeDocumentStepList(&sv.Steps, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentNetworkReachabilityDetails(v **types.NetworkReachabilityDetails, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.NetworkReachabilityDetails
if *v == nil {
sv = &types.NetworkReachabilityDetails{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "networkPath":
if err := awsRestjson1_deserializeDocumentNetworkPath(&sv.NetworkPath, value); err != nil {
return err
}
case "openPortRange":
if err := awsRestjson1_deserializeDocumentPortRange(&sv.OpenPortRange, value); err != nil {
return err
}
case "protocol":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NetworkProtocol to be of type string, got %T instead", value)
}
sv.Protocol = types.NetworkProtocol(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentNonEmptyStringList(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 NonEmptyString to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentNumberFilter(v **types.NumberFilter, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.NumberFilter
if *v == nil {
sv = &types.NumberFilter{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "lowerInclusive":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LowerInclusive = ptr.Float64(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.LowerInclusive = ptr.Float64(f64)
default:
return fmt.Errorf("expected Double to be a JSON Number, got %T instead", value)
}
}
case "upperInclusive":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.UpperInclusive = ptr.Float64(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.UpperInclusive = ptr.Float64(f64)
default:
return fmt.Errorf("expected Double to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentNumberFilterList(v *[]types.NumberFilter, 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.NumberFilter
if *v == nil {
cv = []types.NumberFilter{}
} else {
cv = *v
}
for _, value := range shape {
var col types.NumberFilter
destAddr := &col
if err := awsRestjson1_deserializeDocumentNumberFilter(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentPackageAggregationResponse(v **types.PackageAggregationResponse, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.PackageAggregationResponse
if *v == nil {
sv = &types.PackageAggregationResponse{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "packageName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.PackageName = ptr.String(jtv)
}
case "severityCounts":
if err := awsRestjson1_deserializeDocumentSeverityCounts(&sv.SeverityCounts, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPackageFilter(v **types.PackageFilter, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.PackageFilter
if *v == nil {
sv = &types.PackageFilter{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "architecture":
if err := awsRestjson1_deserializeDocumentStringFilter(&sv.Architecture, value); err != nil {
return err
}
case "epoch":
if err := awsRestjson1_deserializeDocumentNumberFilter(&sv.Epoch, value); err != nil {
return err
}
case "name":
if err := awsRestjson1_deserializeDocumentStringFilter(&sv.Name, value); err != nil {
return err
}
case "release":
if err := awsRestjson1_deserializeDocumentStringFilter(&sv.Release, value); err != nil {
return err
}
case "sourceLambdaLayerArn":
if err := awsRestjson1_deserializeDocumentStringFilter(&sv.SourceLambdaLayerArn, value); err != nil {
return err
}
case "sourceLayerHash":
if err := awsRestjson1_deserializeDocumentStringFilter(&sv.SourceLayerHash, value); err != nil {
return err
}
case "version":
if err := awsRestjson1_deserializeDocumentStringFilter(&sv.Version, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPackageFilterList(v *[]types.PackageFilter, 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.PackageFilter
if *v == nil {
cv = []types.PackageFilter{}
} else {
cv = *v
}
for _, value := range shape {
var col types.PackageFilter
destAddr := &col
if err := awsRestjson1_deserializeDocumentPackageFilter(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentPackageVulnerabilityDetails(v **types.PackageVulnerabilityDetails, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.PackageVulnerabilityDetails
if *v == nil {
sv = &types.PackageVulnerabilityDetails{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "cvss":
if err := awsRestjson1_deserializeDocumentCvssScoreList(&sv.Cvss, value); err != nil {
return err
}
case "referenceUrls":
if err := awsRestjson1_deserializeDocumentNonEmptyStringList(&sv.ReferenceUrls, value); err != nil {
return err
}
case "relatedVulnerabilities":
if err := awsRestjson1_deserializeDocumentVulnerabilityIdList(&sv.RelatedVulnerabilities, value); err != nil {
return err
}
case "source":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.Source = ptr.String(jtv)
}
case "sourceUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.SourceUrl = ptr.String(jtv)
}
case "vendorCreatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.VendorCreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected DateTimeTimestamp to be a JSON Number, got %T instead", value)
}
}
case "vendorSeverity":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.VendorSeverity = ptr.String(jtv)
}
case "vendorUpdatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.VendorUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected DateTimeTimestamp to be a JSON Number, got %T instead", value)
}
}
case "vulnerabilityId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VulnerabilityId to be of type string, got %T instead", value)
}
sv.VulnerabilityId = ptr.String(jtv)
}
case "vulnerablePackages":
if err := awsRestjson1_deserializeDocumentVulnerablePackageList(&sv.VulnerablePackages, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPathList(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 Path to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentPermission(v **types.Permission, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Permission
if *v == nil {
sv = &types.Permission{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "operation":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Operation to be of type string, got %T instead", value)
}
sv.Operation = types.Operation(jtv)
}
case "service":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Service to be of type string, got %T instead", value)
}
sv.Service = types.Service(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPermissions(v *[]types.Permission, 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.Permission
if *v == nil {
cv = []types.Permission{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Permission
destAddr := &col
if err := awsRestjson1_deserializeDocumentPermission(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentPortRange(v **types.PortRange, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.PortRange
if *v == nil {
sv = &types.PortRange{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "begin":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Begin = ptr.Int32(int32(i64))
}
case "end":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.End = ptr.Int32(int32(i64))
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPortRangeFilter(v **types.PortRangeFilter, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.PortRangeFilter
if *v == nil {
sv = &types.PortRangeFilter{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "beginInclusive":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.BeginInclusive = ptr.Int32(int32(i64))
}
case "endInclusive":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected Port to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.EndInclusive = ptr.Int32(int32(i64))
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentPortRangeFilterList(v *[]types.PortRangeFilter, 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.PortRangeFilter
if *v == nil {
cv = []types.PortRangeFilter{}
} else {
cv = *v
}
for _, value := range shape {
var col types.PortRangeFilter
destAddr := &col
if err := awsRestjson1_deserializeDocumentPortRangeFilter(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentRecommendation(v **types.Recommendation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Recommendation
if *v == nil {
sv = &types.Recommendation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "text":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.Text = ptr.String(jtv)
}
case "Url":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.Url = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentReferenceUrls(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 NonEmptyString to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentRelatedVulnerabilities(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 RelatedVulnerability to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentRemediation(v **types.Remediation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Remediation
if *v == nil {
sv = &types.Remediation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "recommendation":
if err := awsRestjson1_deserializeDocumentRecommendation(&sv.Recommendation, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentRepositoryAggregationResponse(v **types.RepositoryAggregationResponse, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.RepositoryAggregationResponse
if *v == nil {
sv = &types.RepositoryAggregationResponse{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "affectedImages":
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.AffectedImages = ptr.Int64(i64)
}
case "repository":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.Repository = ptr.String(jtv)
}
case "severityCounts":
if err := awsRestjson1_deserializeDocumentSeverityCounts(&sv.SeverityCounts, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResource(v **types.Resource, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Resource
if *v == nil {
sv = &types.Resource{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "details":
if err := awsRestjson1_deserializeDocumentResourceDetails(&sv.Details, value); err != nil {
return err
}
case "id":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.Id = ptr.String(jtv)
}
case "partition":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.Partition = ptr.String(jtv)
}
case "region":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.Region = ptr.String(jtv)
}
case "tags":
if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil {
return err
}
case "type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
}
sv.Type = types.ResourceType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResourceDetails(v **types.ResourceDetails, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ResourceDetails
if *v == nil {
sv = &types.ResourceDetails{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "awsEc2Instance":
if err := awsRestjson1_deserializeDocumentAwsEc2InstanceDetails(&sv.AwsEc2Instance, value); err != nil {
return err
}
case "awsEcrContainerImage":
if err := awsRestjson1_deserializeDocumentAwsEcrContainerImageDetails(&sv.AwsEcrContainerImage, value); err != nil {
return err
}
case "awsLambdaFunction":
if err := awsRestjson1_deserializeDocumentAwsLambdaFunctionDetails(&sv.AwsLambdaFunction, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResourceFilterCriteria(v **types.ResourceFilterCriteria, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ResourceFilterCriteria
if *v == nil {
sv = &types.ResourceFilterCriteria{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if err := awsRestjson1_deserializeDocumentResourceStringFilterList(&sv.AccountId, value); err != nil {
return err
}
case "ec2InstanceTags":
if err := awsRestjson1_deserializeDocumentResourceMapFilterList(&sv.Ec2InstanceTags, value); err != nil {
return err
}
case "ecrImageTags":
if err := awsRestjson1_deserializeDocumentResourceStringFilterList(&sv.EcrImageTags, value); err != nil {
return err
}
case "ecrRepositoryName":
if err := awsRestjson1_deserializeDocumentResourceStringFilterList(&sv.EcrRepositoryName, value); err != nil {
return err
}
case "lambdaFunctionName":
if err := awsRestjson1_deserializeDocumentResourceStringFilterList(&sv.LambdaFunctionName, value); err != nil {
return err
}
case "lambdaFunctionTags":
if err := awsRestjson1_deserializeDocumentResourceMapFilterList(&sv.LambdaFunctionTags, value); err != nil {
return err
}
case "resourceId":
if err := awsRestjson1_deserializeDocumentResourceStringFilterList(&sv.ResourceId, value); err != nil {
return err
}
case "resourceType":
if err := awsRestjson1_deserializeDocumentResourceStringFilterList(&sv.ResourceType, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResourceList(v *[]types.Resource, 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.Resource
if *v == nil {
cv = []types.Resource{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Resource
destAddr := &col
if err := awsRestjson1_deserializeDocumentResource(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentResourceMapFilter(v **types.ResourceMapFilter, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ResourceMapFilter
if *v == nil {
sv = &types.ResourceMapFilter{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "comparison":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceMapComparison to be of type string, got %T instead", value)
}
sv.Comparison = types.ResourceMapComparison(jtv)
}
case "key":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString 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 NonEmptyString to be of type string, got %T instead", value)
}
sv.Value = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResourceMapFilterList(v *[]types.ResourceMapFilter, 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.ResourceMapFilter
if *v == nil {
cv = []types.ResourceMapFilter{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ResourceMapFilter
destAddr := &col
if err := awsRestjson1_deserializeDocumentResourceMapFilter(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ResourceNotFoundException
if *v == nil {
sv = &types.ResourceNotFoundException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResourceScanMetadata(v **types.ResourceScanMetadata, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ResourceScanMetadata
if *v == nil {
sv = &types.ResourceScanMetadata{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ec2":
if err := awsRestjson1_deserializeDocumentEc2Metadata(&sv.Ec2, value); err != nil {
return err
}
case "ecrImage":
if err := awsRestjson1_deserializeDocumentEcrContainerImageMetadata(&sv.EcrImage, value); err != nil {
return err
}
case "ecrRepository":
if err := awsRestjson1_deserializeDocumentEcrRepositoryMetadata(&sv.EcrRepository, value); err != nil {
return err
}
case "lambdaFunction":
if err := awsRestjson1_deserializeDocumentLambdaFunctionMetadata(&sv.LambdaFunction, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResourceState(v **types.ResourceState, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ResourceState
if *v == nil {
sv = &types.ResourceState{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ec2":
if err := awsRestjson1_deserializeDocumentState(&sv.Ec2, value); err != nil {
return err
}
case "ecr":
if err := awsRestjson1_deserializeDocumentState(&sv.Ecr, value); err != nil {
return err
}
case "lambda":
if err := awsRestjson1_deserializeDocumentState(&sv.Lambda, value); err != nil {
return err
}
case "lambdaCode":
if err := awsRestjson1_deserializeDocumentState(&sv.LambdaCode, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResourceStatus(v **types.ResourceStatus, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ResourceStatus
if *v == nil {
sv = &types.ResourceStatus{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ec2":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Status to be of type string, got %T instead", value)
}
sv.Ec2 = types.Status(jtv)
}
case "ecr":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Status to be of type string, got %T instead", value)
}
sv.Ecr = types.Status(jtv)
}
case "lambda":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Status to be of type string, got %T instead", value)
}
sv.Lambda = types.Status(jtv)
}
case "lambdaCode":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Status to be of type string, got %T instead", value)
}
sv.LambdaCode = types.Status(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResourceStringFilter(v **types.ResourceStringFilter, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ResourceStringFilter
if *v == nil {
sv = &types.ResourceStringFilter{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "comparison":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceStringComparison to be of type string, got %T instead", value)
}
sv.Comparison = types.ResourceStringComparison(jtv)
}
case "value":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceStringInput to be of type string, got %T instead", value)
}
sv.Value = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentResourceStringFilterList(v *[]types.ResourceStringFilter, 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.ResourceStringFilter
if *v == nil {
cv = []types.ResourceStringFilter{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ResourceStringFilter
destAddr := &col
if err := awsRestjson1_deserializeDocumentResourceStringFilter(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentScanStatus(v **types.ScanStatus, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ScanStatus
if *v == nil {
sv = &types.ScanStatus{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "reason":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ScanStatusReason to be of type string, got %T instead", value)
}
sv.Reason = types.ScanStatusReason(jtv)
}
case "statusCode":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ScanStatusCode to be of type string, got %T instead", value)
}
sv.StatusCode = types.ScanStatusCode(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSecurityGroupIdList(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 SecurityGroupId to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentServiceQuotaExceededException(v **types.ServiceQuotaExceededException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ServiceQuotaExceededException
if *v == nil {
sv = &types.ServiceQuotaExceededException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
case "resourceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.ResourceId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSeverityCounts(v **types.SeverityCounts, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.SeverityCounts
if *v == nil {
sv = &types.SeverityCounts{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "all":
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.All = ptr.Int64(i64)
}
case "critical":
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.Critical = ptr.Int64(i64)
}
case "high":
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.High = ptr.Int64(i64)
}
case "medium":
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.Medium = ptr.Int64(i64)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentState(v **types.State, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.State
if *v == nil {
sv = &types.State{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "errorCode":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorCode to be of type string, got %T instead", value)
}
sv.ErrorCode = types.ErrorCode(jtv)
}
case "errorMessage":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.ErrorMessage = ptr.String(jtv)
}
case "status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Status to be of type string, got %T instead", value)
}
sv.Status = types.Status(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentStep(v **types.Step, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Step
if *v == nil {
sv = &types.Step{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "componentId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Component to be of type string, got %T instead", value)
}
sv.ComponentId = ptr.String(jtv)
}
case "componentType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ComponentType to be of type string, got %T instead", value)
}
sv.ComponentType = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentStepList(v *[]types.Step, 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.Step
if *v == nil {
cv = []types.Step{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Step
destAddr := &col
if err := awsRestjson1_deserializeDocumentStep(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentStringFilter(v **types.StringFilter, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.StringFilter
if *v == nil {
sv = &types.StringFilter{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "comparison":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected StringComparison to be of type string, got %T instead", value)
}
sv.Comparison = types.StringComparison(jtv)
}
case "value":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected StringInput to be of type string, got %T instead", value)
}
sv.Value = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentStringFilterList(v *[]types.StringFilter, 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.StringFilter
if *v == nil {
cv = []types.StringFilter{}
} else {
cv = *v
}
for _, value := range shape {
var col types.StringFilter
destAddr := &col
if err := awsRestjson1_deserializeDocumentStringFilter(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentStringList(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 NonEmptyString to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentSubnetIdList(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 SubnetId to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentSuggestedFix(v **types.SuggestedFix, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.SuggestedFix
if *v == nil {
sv = &types.SuggestedFix{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "code":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Code = 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)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentSuggestedFixes(v *[]types.SuggestedFix, 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.SuggestedFix
if *v == nil {
cv = []types.SuggestedFix{}
} else {
cv = *v
}
for _, value := range shape {
var col types.SuggestedFix
destAddr := &col
if err := awsRestjson1_deserializeDocumentSuggestedFix(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentTagList(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_deserializeDocumentTagMap(v *map[string]string, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var mv map[string]string
if *v == nil {
mv = map[string]string{}
} else {
mv = *v
}
for key, value := range shape {
var parsedVal string
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MapValue to be of type string, got %T instead", value)
}
parsedVal = jtv
}
mv[key] = parsedVal
}
*v = mv
return nil
}
func awsRestjson1_deserializeDocumentTargets(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 Target to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentThrottlingException(v **types.ThrottlingException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ThrottlingException
if *v == nil {
sv = &types.ThrottlingException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
case "retryAfterSeconds":
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.RetryAfterSeconds = ptr.Int32(int32(i64))
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTitleAggregationResponse(v **types.TitleAggregationResponse, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.TitleAggregationResponse
if *v == nil {
sv = &types.TitleAggregationResponse{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "severityCounts":
if err := awsRestjson1_deserializeDocumentSeverityCounts(&sv.SeverityCounts, value); err != nil {
return err
}
case "title":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.Title = ptr.String(jtv)
}
case "vulnerabilityId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.VulnerabilityId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentTtps(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 Ttp to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentUsage(v **types.Usage, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Usage
if *v == nil {
sv = &types.Usage{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "currency":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Currency to be of type string, got %T instead", value)
}
sv.Currency = types.Currency(jtv)
}
case "estimatedMonthlyCost":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.EstimatedMonthlyCost = 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.EstimatedMonthlyCost = f64
default:
return fmt.Errorf("expected MonthlyCostEstimate to be a JSON Number, got %T instead", value)
}
}
case "total":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.Total = 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.Total = f64
default:
return fmt.Errorf("expected UsageValue to be a JSON Number, got %T instead", value)
}
}
case "type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UsageType to be of type string, got %T instead", value)
}
sv.Type = types.UsageType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentUsageList(v *[]types.Usage, 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.Usage
if *v == nil {
cv = []types.Usage{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Usage
destAddr := &col
if err := awsRestjson1_deserializeDocumentUsage(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentUsageTotal(v **types.UsageTotal, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.UsageTotal
if *v == nil {
sv = &types.UsageTotal{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "accountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MeteringAccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "usage":
if err := awsRestjson1_deserializeDocumentUsageList(&sv.Usage, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentUsageTotalList(v *[]types.UsageTotal, 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.UsageTotal
if *v == nil {
cv = []types.UsageTotal{}
} else {
cv = *v
}
for _, value := range shape {
var col types.UsageTotal
destAddr := &col
if err := awsRestjson1_deserializeDocumentUsageTotal(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ValidationException
if *v == nil {
sv = &types.ValidationException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "fields":
if err := awsRestjson1_deserializeDocumentValidationExceptionFields(&sv.Fields, value); err != nil {
return err
}
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 "reason":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ValidationExceptionReason to be of type string, got %T instead", value)
}
sv.Reason = types.ValidationExceptionReason(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentValidationExceptionField(v **types.ValidationExceptionField, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ValidationExceptionField
if *v == nil {
sv = &types.ValidationExceptionField{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected String to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
case "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_deserializeDocumentValidationExceptionFields(v *[]types.ValidationExceptionField, 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.ValidationExceptionField
if *v == nil {
cv = []types.ValidationExceptionField{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ValidationExceptionField
destAddr := &col
if err := awsRestjson1_deserializeDocumentValidationExceptionField(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentVulnerabilities(v *[]types.Vulnerability, 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.Vulnerability
if *v == nil {
cv = []types.Vulnerability{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Vulnerability
destAddr := &col
if err := awsRestjson1_deserializeDocumentVulnerability(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentVulnerability(v **types.Vulnerability, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Vulnerability
if *v == nil {
sv = &types.Vulnerability{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "atigData":
if err := awsRestjson1_deserializeDocumentAtigData(&sv.AtigData, value); err != nil {
return err
}
case "cisaData":
if err := awsRestjson1_deserializeDocumentCisaData(&sv.CisaData, value); err != nil {
return err
}
case "cvss2":
if err := awsRestjson1_deserializeDocumentCvss2(&sv.Cvss2, value); err != nil {
return err
}
case "cvss3":
if err := awsRestjson1_deserializeDocumentCvss3(&sv.Cvss3, value); err != nil {
return err
}
case "cwes":
if err := awsRestjson1_deserializeDocumentCwes(&sv.Cwes, value); err != nil {
return err
}
case "description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VulnerabilityDescription to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "detectionPlatforms":
if err := awsRestjson1_deserializeDocumentDetectionPlatforms(&sv.DetectionPlatforms, value); err != nil {
return err
}
case "epss":
if err := awsRestjson1_deserializeDocumentEpss(&sv.Epss, value); err != nil {
return err
}
case "exploitObserved":
if err := awsRestjson1_deserializeDocumentExploitObserved(&sv.ExploitObserved, value); err != nil {
return err
}
case "id":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NonEmptyString to be of type string, got %T instead", value)
}
sv.Id = ptr.String(jtv)
}
case "referenceUrls":
if err := awsRestjson1_deserializeDocumentVulnerabilityReferenceUrls(&sv.ReferenceUrls, value); err != nil {
return err
}
case "relatedVulnerabilities":
if err := awsRestjson1_deserializeDocumentRelatedVulnerabilities(&sv.RelatedVulnerabilities, value); err != nil {
return err
}
case "source":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VulnerabilitySource to be of type string, got %T instead", value)
}
sv.Source = types.VulnerabilitySource(jtv)
}
case "sourceUrl":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VulnerabilitySourceUrl to be of type string, got %T instead", value)
}
sv.SourceUrl = ptr.String(jtv)
}
case "vendorCreatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.VendorCreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected VendorCreatedAt to be a JSON Number, got %T instead", value)
}
}
case "vendorSeverity":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VendorSeverity to be of type string, got %T instead", value)
}
sv.VendorSeverity = ptr.String(jtv)
}
case "vendorUpdatedAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.VendorUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected VendorUpdatedAt to be a JSON Number, got %T instead", value)
}
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentVulnerabilityIdList(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 VulnerabilityId to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentVulnerabilityReferenceUrls(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 VulnerabilityReferenceUrl to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsRestjson1_deserializeDocumentVulnerablePackage(v **types.VulnerablePackage, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.VulnerablePackage
if *v == nil {
sv = &types.VulnerablePackage{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "arch":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PackageArchitecture to be of type string, got %T instead", value)
}
sv.Arch = ptr.String(jtv)
}
case "epoch":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected PackageEpoch to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Epoch = int32(i64)
}
case "filePath":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FilePath to be of type string, got %T instead", value)
}
sv.FilePath = ptr.String(jtv)
}
case "fixedInVersion":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PackageVersion to be of type string, got %T instead", value)
}
sv.FixedInVersion = ptr.String(jtv)
}
case "name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PackageName to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "packageManager":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PackageManager to be of type string, got %T instead", value)
}
sv.PackageManager = types.PackageManager(jtv)
}
case "release":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PackageRelease to be of type string, got %T instead", value)
}
sv.Release = ptr.String(jtv)
}
case "remediation":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected VulnerablePackageRemediation to be of type string, got %T instead", value)
}
sv.Remediation = ptr.String(jtv)
}
case "sourceLambdaLayerArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LambdaLayerArn to be of type string, got %T instead", value)
}
sv.SourceLambdaLayerArn = ptr.String(jtv)
}
case "sourceLayerHash":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SourceLayerHash to be of type string, got %T instead", value)
}
sv.SourceLayerHash = ptr.String(jtv)
}
case "version":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PackageVersion to be of type string, got %T instead", value)
}
sv.Version = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsRestjson1_deserializeDocumentVulnerablePackageList(v *[]types.VulnerablePackage, 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.VulnerablePackage
if *v == nil {
cv = []types.VulnerablePackage{}
} else {
cv = *v
}
for _, value := range shape {
var col types.VulnerablePackage
destAddr := &col
if err := awsRestjson1_deserializeDocumentVulnerablePackage(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
| 16,173 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package inspector2 provides the API client, operations, and parameter types for
// Inspector2.
//
// Amazon Inspector is a vulnerability discovery service that automates continuous
// scanning for security vulnerabilities within your Amazon EC2 and Amazon ECR
// environments.
package inspector2
| 10 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
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/inspector2/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 = "inspector2"
}
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 inspector2
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.15.0"
| 7 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
import (
"bytes"
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/inspector2/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/encoding/httpbinding"
smithyjson "github.com/aws/smithy-go/encoding/json"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
"math"
)
type awsRestjson1_serializeOpAssociateMember struct {
}
func (*awsRestjson1_serializeOpAssociateMember) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpAssociateMember) 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.(*AssociateMemberInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/members/associate")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentAssociateMemberInput(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_serializeOpHttpBindingsAssociateMemberInput(v *AssociateMemberInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentAssociateMemberInput(v *AssociateMemberInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccountId != nil {
ok := object.Key("accountId")
ok.String(*v.AccountId)
}
return nil
}
type awsRestjson1_serializeOpBatchGetAccountStatus struct {
}
func (*awsRestjson1_serializeOpBatchGetAccountStatus) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpBatchGetAccountStatus) 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.(*BatchGetAccountStatusInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/status/batch/get")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentBatchGetAccountStatusInput(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_serializeOpHttpBindingsBatchGetAccountStatusInput(v *BatchGetAccountStatusInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentBatchGetAccountStatusInput(v *BatchGetAccountStatusInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccountIds != nil {
ok := object.Key("accountIds")
if err := awsRestjson1_serializeDocumentAccountIdSet(v.AccountIds, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpBatchGetCodeSnippet struct {
}
func (*awsRestjson1_serializeOpBatchGetCodeSnippet) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpBatchGetCodeSnippet) 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.(*BatchGetCodeSnippetInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/codesnippet/batchget")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentBatchGetCodeSnippetInput(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_serializeOpHttpBindingsBatchGetCodeSnippetInput(v *BatchGetCodeSnippetInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentBatchGetCodeSnippetInput(v *BatchGetCodeSnippetInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FindingArns != nil {
ok := object.Key("findingArns")
if err := awsRestjson1_serializeDocumentFindingArns(v.FindingArns, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpBatchGetFreeTrialInfo struct {
}
func (*awsRestjson1_serializeOpBatchGetFreeTrialInfo) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpBatchGetFreeTrialInfo) 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.(*BatchGetFreeTrialInfoInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/freetrialinfo/batchget")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentBatchGetFreeTrialInfoInput(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_serializeOpHttpBindingsBatchGetFreeTrialInfoInput(v *BatchGetFreeTrialInfoInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentBatchGetFreeTrialInfoInput(v *BatchGetFreeTrialInfoInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccountIds != nil {
ok := object.Key("accountIds")
if err := awsRestjson1_serializeDocumentMeteringAccountIdList(v.AccountIds, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpBatchGetMemberEc2DeepInspectionStatus struct {
}
func (*awsRestjson1_serializeOpBatchGetMemberEc2DeepInspectionStatus) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpBatchGetMemberEc2DeepInspectionStatus) 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.(*BatchGetMemberEc2DeepInspectionStatusInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/ec2deepinspectionstatus/member/batch/get")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentBatchGetMemberEc2DeepInspectionStatusInput(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_serializeOpHttpBindingsBatchGetMemberEc2DeepInspectionStatusInput(v *BatchGetMemberEc2DeepInspectionStatusInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentBatchGetMemberEc2DeepInspectionStatusInput(v *BatchGetMemberEc2DeepInspectionStatusInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccountIds != nil {
ok := object.Key("accountIds")
if err := awsRestjson1_serializeDocumentAccountIdSet(v.AccountIds, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpBatchUpdateMemberEc2DeepInspectionStatus struct {
}
func (*awsRestjson1_serializeOpBatchUpdateMemberEc2DeepInspectionStatus) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpBatchUpdateMemberEc2DeepInspectionStatus) 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.(*BatchUpdateMemberEc2DeepInspectionStatusInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/ec2deepinspectionstatus/member/batch/update")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentBatchUpdateMemberEc2DeepInspectionStatusInput(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_serializeOpHttpBindingsBatchUpdateMemberEc2DeepInspectionStatusInput(v *BatchUpdateMemberEc2DeepInspectionStatusInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentBatchUpdateMemberEc2DeepInspectionStatusInput(v *BatchUpdateMemberEc2DeepInspectionStatusInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccountIds != nil {
ok := object.Key("accountIds")
if err := awsRestjson1_serializeDocumentMemberAccountEc2DeepInspectionStatusList(v.AccountIds, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCancelFindingsReport struct {
}
func (*awsRestjson1_serializeOpCancelFindingsReport) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCancelFindingsReport) 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.(*CancelFindingsReportInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/reporting/cancel")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCancelFindingsReportInput(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_serializeOpHttpBindingsCancelFindingsReportInput(v *CancelFindingsReportInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCancelFindingsReportInput(v *CancelFindingsReportInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ReportId != nil {
ok := object.Key("reportId")
ok.String(*v.ReportId)
}
return nil
}
type awsRestjson1_serializeOpCancelSbomExport struct {
}
func (*awsRestjson1_serializeOpCancelSbomExport) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCancelSbomExport) 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.(*CancelSbomExportInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sbomexport/cancel")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCancelSbomExportInput(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_serializeOpHttpBindingsCancelSbomExportInput(v *CancelSbomExportInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCancelSbomExportInput(v *CancelSbomExportInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ReportId != nil {
ok := object.Key("reportId")
ok.String(*v.ReportId)
}
return nil
}
type awsRestjson1_serializeOpCreateFilter struct {
}
func (*awsRestjson1_serializeOpCreateFilter) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateFilter) 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.(*CreateFilterInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/filters/create")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateFilterInput(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_serializeOpHttpBindingsCreateFilterInput(v *CreateFilterInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateFilterInput(v *CreateFilterInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Action) > 0 {
ok := object.Key("action")
ok.String(string(v.Action))
}
if v.Description != nil {
ok := object.Key("description")
ok.String(*v.Description)
}
if v.FilterCriteria != nil {
ok := object.Key("filterCriteria")
if err := awsRestjson1_serializeDocumentFilterCriteria(v.FilterCriteria, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
if v.Reason != nil {
ok := object.Key("reason")
ok.String(*v.Reason)
}
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateFindingsReport struct {
}
func (*awsRestjson1_serializeOpCreateFindingsReport) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateFindingsReport) 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.(*CreateFindingsReportInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/reporting/create")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateFindingsReportInput(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_serializeOpHttpBindingsCreateFindingsReportInput(v *CreateFindingsReportInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateFindingsReportInput(v *CreateFindingsReportInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FilterCriteria != nil {
ok := object.Key("filterCriteria")
if err := awsRestjson1_serializeDocumentFilterCriteria(v.FilterCriteria, ok); err != nil {
return err
}
}
if len(v.ReportFormat) > 0 {
ok := object.Key("reportFormat")
ok.String(string(v.ReportFormat))
}
if v.S3Destination != nil {
ok := object.Key("s3Destination")
if err := awsRestjson1_serializeDocumentDestination(v.S3Destination, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpCreateSbomExport struct {
}
func (*awsRestjson1_serializeOpCreateSbomExport) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpCreateSbomExport) 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.(*CreateSbomExportInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sbomexport/create")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentCreateSbomExportInput(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_serializeOpHttpBindingsCreateSbomExportInput(v *CreateSbomExportInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentCreateSbomExportInput(v *CreateSbomExportInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.ReportFormat) > 0 {
ok := object.Key("reportFormat")
ok.String(string(v.ReportFormat))
}
if v.ResourceFilterCriteria != nil {
ok := object.Key("resourceFilterCriteria")
if err := awsRestjson1_serializeDocumentResourceFilterCriteria(v.ResourceFilterCriteria, ok); err != nil {
return err
}
}
if v.S3Destination != nil {
ok := object.Key("s3Destination")
if err := awsRestjson1_serializeDocumentDestination(v.S3Destination, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDeleteFilter struct {
}
func (*awsRestjson1_serializeOpDeleteFilter) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDeleteFilter) 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.(*DeleteFilterInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/filters/delete")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentDeleteFilterInput(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_serializeOpHttpBindingsDeleteFilterInput(v *DeleteFilterInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentDeleteFilterInput(v *DeleteFilterInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Arn != nil {
ok := object.Key("arn")
ok.String(*v.Arn)
}
return nil
}
type awsRestjson1_serializeOpDescribeOrganizationConfiguration struct {
}
func (*awsRestjson1_serializeOpDescribeOrganizationConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDescribeOrganizationConfiguration) 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.(*DescribeOrganizationConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/organizationconfiguration/describe")
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 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_serializeOpHttpBindingsDescribeOrganizationConfigurationInput(v *DescribeOrganizationConfigurationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
type awsRestjson1_serializeOpDisable struct {
}
func (*awsRestjson1_serializeOpDisable) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDisable) 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.(*DisableInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/disable")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentDisableInput(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_serializeOpHttpBindingsDisableInput(v *DisableInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentDisableInput(v *DisableInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccountIds != nil {
ok := object.Key("accountIds")
if err := awsRestjson1_serializeDocumentAccountIdSet(v.AccountIds, ok); err != nil {
return err
}
}
if v.ResourceTypes != nil {
ok := object.Key("resourceTypes")
if err := awsRestjson1_serializeDocumentDisableResourceTypeList(v.ResourceTypes, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpDisableDelegatedAdminAccount struct {
}
func (*awsRestjson1_serializeOpDisableDelegatedAdminAccount) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDisableDelegatedAdminAccount) 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.(*DisableDelegatedAdminAccountInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/delegatedadminaccounts/disable")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentDisableDelegatedAdminAccountInput(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_serializeOpHttpBindingsDisableDelegatedAdminAccountInput(v *DisableDelegatedAdminAccountInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentDisableDelegatedAdminAccountInput(v *DisableDelegatedAdminAccountInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DelegatedAdminAccountId != nil {
ok := object.Key("delegatedAdminAccountId")
ok.String(*v.DelegatedAdminAccountId)
}
return nil
}
type awsRestjson1_serializeOpDisassociateMember struct {
}
func (*awsRestjson1_serializeOpDisassociateMember) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpDisassociateMember) 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.(*DisassociateMemberInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/members/disassociate")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentDisassociateMemberInput(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_serializeOpHttpBindingsDisassociateMemberInput(v *DisassociateMemberInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentDisassociateMemberInput(v *DisassociateMemberInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccountId != nil {
ok := object.Key("accountId")
ok.String(*v.AccountId)
}
return nil
}
type awsRestjson1_serializeOpEnable struct {
}
func (*awsRestjson1_serializeOpEnable) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpEnable) 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.(*EnableInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/enable")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentEnableInput(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_serializeOpHttpBindingsEnableInput(v *EnableInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentEnableInput(v *EnableInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccountIds != nil {
ok := object.Key("accountIds")
if err := awsRestjson1_serializeDocumentAccountIdSet(v.AccountIds, ok); err != nil {
return err
}
}
if v.ClientToken != nil {
ok := object.Key("clientToken")
ok.String(*v.ClientToken)
}
if v.ResourceTypes != nil {
ok := object.Key("resourceTypes")
if err := awsRestjson1_serializeDocumentEnableResourceTypeList(v.ResourceTypes, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpEnableDelegatedAdminAccount struct {
}
func (*awsRestjson1_serializeOpEnableDelegatedAdminAccount) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpEnableDelegatedAdminAccount) 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.(*EnableDelegatedAdminAccountInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/delegatedadminaccounts/enable")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentEnableDelegatedAdminAccountInput(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_serializeOpHttpBindingsEnableDelegatedAdminAccountInput(v *EnableDelegatedAdminAccountInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentEnableDelegatedAdminAccountInput(v *EnableDelegatedAdminAccountInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ClientToken != nil {
ok := object.Key("clientToken")
ok.String(*v.ClientToken)
}
if v.DelegatedAdminAccountId != nil {
ok := object.Key("delegatedAdminAccountId")
ok.String(*v.DelegatedAdminAccountId)
}
return nil
}
type awsRestjson1_serializeOpGetConfiguration struct {
}
func (*awsRestjson1_serializeOpGetConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetConfiguration) 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.(*GetConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/configuration/get")
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 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_serializeOpHttpBindingsGetConfigurationInput(v *GetConfigurationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
type awsRestjson1_serializeOpGetDelegatedAdminAccount struct {
}
func (*awsRestjson1_serializeOpGetDelegatedAdminAccount) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetDelegatedAdminAccount) 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.(*GetDelegatedAdminAccountInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/delegatedadminaccounts/get")
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 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_serializeOpHttpBindingsGetDelegatedAdminAccountInput(v *GetDelegatedAdminAccountInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
type awsRestjson1_serializeOpGetEc2DeepInspectionConfiguration struct {
}
func (*awsRestjson1_serializeOpGetEc2DeepInspectionConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetEc2DeepInspectionConfiguration) 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.(*GetEc2DeepInspectionConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/ec2deepinspectionconfiguration/get")
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 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_serializeOpHttpBindingsGetEc2DeepInspectionConfigurationInput(v *GetEc2DeepInspectionConfigurationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
type awsRestjson1_serializeOpGetEncryptionKey struct {
}
func (*awsRestjson1_serializeOpGetEncryptionKey) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetEncryptionKey) 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.(*GetEncryptionKeyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/encryptionkey/get")
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_serializeOpHttpBindingsGetEncryptionKeyInput(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_serializeOpHttpBindingsGetEncryptionKeyInput(v *GetEncryptionKeyInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if len(v.ResourceType) > 0 {
encoder.SetQuery("resourceType").String(string(v.ResourceType))
}
if len(v.ScanType) > 0 {
encoder.SetQuery("scanType").String(string(v.ScanType))
}
return nil
}
type awsRestjson1_serializeOpGetFindingsReportStatus struct {
}
func (*awsRestjson1_serializeOpGetFindingsReportStatus) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetFindingsReportStatus) 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.(*GetFindingsReportStatusInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/reporting/status/get")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGetFindingsReportStatusInput(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_serializeOpHttpBindingsGetFindingsReportStatusInput(v *GetFindingsReportStatusInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGetFindingsReportStatusInput(v *GetFindingsReportStatusInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ReportId != nil {
ok := object.Key("reportId")
ok.String(*v.ReportId)
}
return nil
}
type awsRestjson1_serializeOpGetMember struct {
}
func (*awsRestjson1_serializeOpGetMember) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetMember) 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.(*GetMemberInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/members/get")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGetMemberInput(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_serializeOpHttpBindingsGetMemberInput(v *GetMemberInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGetMemberInput(v *GetMemberInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccountId != nil {
ok := object.Key("accountId")
ok.String(*v.AccountId)
}
return nil
}
type awsRestjson1_serializeOpGetSbomExport struct {
}
func (*awsRestjson1_serializeOpGetSbomExport) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpGetSbomExport) 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.(*GetSbomExportInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/sbomexport/get")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentGetSbomExportInput(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_serializeOpHttpBindingsGetSbomExportInput(v *GetSbomExportInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentGetSbomExportInput(v *GetSbomExportInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ReportId != nil {
ok := object.Key("reportId")
ok.String(*v.ReportId)
}
return nil
}
type awsRestjson1_serializeOpListAccountPermissions struct {
}
func (*awsRestjson1_serializeOpListAccountPermissions) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListAccountPermissions) 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.(*ListAccountPermissionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/accountpermissions/list")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListAccountPermissionsInput(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_serializeOpHttpBindingsListAccountPermissionsInput(v *ListAccountPermissionsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentListAccountPermissionsInput(v *ListAccountPermissionsInput, 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 len(v.Service) > 0 {
ok := object.Key("service")
ok.String(string(v.Service))
}
return nil
}
type awsRestjson1_serializeOpListCoverage struct {
}
func (*awsRestjson1_serializeOpListCoverage) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListCoverage) 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.(*ListCoverageInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/coverage/list")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListCoverageInput(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_serializeOpHttpBindingsListCoverageInput(v *ListCoverageInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentListCoverageInput(v *ListCoverageInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FilterCriteria != nil {
ok := object.Key("filterCriteria")
if err := awsRestjson1_serializeDocumentCoverageFilterCriteria(v.FilterCriteria, ok); err != nil {
return err
}
}
if v.MaxResults != nil {
ok := object.Key("maxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("nextToken")
ok.String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListCoverageStatistics struct {
}
func (*awsRestjson1_serializeOpListCoverageStatistics) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListCoverageStatistics) 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.(*ListCoverageStatisticsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/coverage/statistics/list")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListCoverageStatisticsInput(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_serializeOpHttpBindingsListCoverageStatisticsInput(v *ListCoverageStatisticsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentListCoverageStatisticsInput(v *ListCoverageStatisticsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FilterCriteria != nil {
ok := object.Key("filterCriteria")
if err := awsRestjson1_serializeDocumentCoverageFilterCriteria(v.FilterCriteria, ok); err != nil {
return err
}
}
if len(v.GroupBy) > 0 {
ok := object.Key("groupBy")
ok.String(string(v.GroupBy))
}
if v.NextToken != nil {
ok := object.Key("nextToken")
ok.String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListDelegatedAdminAccounts struct {
}
func (*awsRestjson1_serializeOpListDelegatedAdminAccounts) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListDelegatedAdminAccounts) 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.(*ListDelegatedAdminAccountsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/delegatedadminaccounts/list")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListDelegatedAdminAccountsInput(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_serializeOpHttpBindingsListDelegatedAdminAccountsInput(v *ListDelegatedAdminAccountsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentListDelegatedAdminAccountsInput(v *ListDelegatedAdminAccountsInput, 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)
}
return nil
}
type awsRestjson1_serializeOpListFilters struct {
}
func (*awsRestjson1_serializeOpListFilters) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListFilters) 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.(*ListFiltersInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/filters/list")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListFiltersInput(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_serializeOpHttpBindingsListFiltersInput(v *ListFiltersInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentListFiltersInput(v *ListFiltersInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Action) > 0 {
ok := object.Key("action")
ok.String(string(v.Action))
}
if v.Arns != nil {
ok := object.Key("arns")
if err := awsRestjson1_serializeDocumentFilterArnList(v.Arns, ok); err != nil {
return err
}
}
if v.MaxResults != nil {
ok := object.Key("maxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("nextToken")
ok.String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListFindingAggregations struct {
}
func (*awsRestjson1_serializeOpListFindingAggregations) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListFindingAggregations) 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.(*ListFindingAggregationsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/findings/aggregation/list")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListFindingAggregationsInput(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_serializeOpHttpBindingsListFindingAggregationsInput(v *ListFindingAggregationsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentListFindingAggregationsInput(v *ListFindingAggregationsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccountIds != nil {
ok := object.Key("accountIds")
if err := awsRestjson1_serializeDocumentStringFilterList(v.AccountIds, ok); err != nil {
return err
}
}
if v.AggregationRequest != nil {
ok := object.Key("aggregationRequest")
if err := awsRestjson1_serializeDocumentAggregationRequest(v.AggregationRequest, ok); err != nil {
return err
}
}
if len(v.AggregationType) > 0 {
ok := object.Key("aggregationType")
ok.String(string(v.AggregationType))
}
if v.MaxResults != nil {
ok := object.Key("maxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("nextToken")
ok.String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpListFindings struct {
}
func (*awsRestjson1_serializeOpListFindings) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListFindings) 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.(*ListFindingsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/findings/list")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListFindingsInput(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_serializeOpHttpBindingsListFindingsInput(v *ListFindingsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentListFindingsInput(v *ListFindingsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FilterCriteria != nil {
ok := object.Key("filterCriteria")
if err := awsRestjson1_serializeDocumentFilterCriteria(v.FilterCriteria, 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.SortCriteria != nil {
ok := object.Key("sortCriteria")
if err := awsRestjson1_serializeDocumentSortCriteria(v.SortCriteria, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpListMembers struct {
}
func (*awsRestjson1_serializeOpListMembers) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListMembers) 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.(*ListMembersInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/members/list")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListMembersInput(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_serializeOpHttpBindingsListMembersInput(v *ListMembersInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentListMembersInput(v *ListMembersInput, 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.OnlyAssociated != nil {
ok := object.Key("onlyAssociated")
ok.Boolean(*v.OnlyAssociated)
}
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_serializeOpListUsageTotals struct {
}
func (*awsRestjson1_serializeOpListUsageTotals) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpListUsageTotals) 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.(*ListUsageTotalsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/usage/list")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentListUsageTotalsInput(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_serializeOpHttpBindingsListUsageTotalsInput(v *ListUsageTotalsInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentListUsageTotalsInput(v *ListUsageTotalsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccountIds != nil {
ok := object.Key("accountIds")
if err := awsRestjson1_serializeDocumentUsageAccountIdList(v.AccountIds, ok); err != nil {
return err
}
}
if v.MaxResults != nil {
ok := object.Key("maxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("nextToken")
ok.String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpResetEncryptionKey struct {
}
func (*awsRestjson1_serializeOpResetEncryptionKey) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpResetEncryptionKey) 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.(*ResetEncryptionKeyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/encryptionkey/reset")
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_serializeOpDocumentResetEncryptionKeyInput(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_serializeOpHttpBindingsResetEncryptionKeyInput(v *ResetEncryptionKeyInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentResetEncryptionKeyInput(v *ResetEncryptionKeyInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.ResourceType) > 0 {
ok := object.Key("resourceType")
ok.String(string(v.ResourceType))
}
if len(v.ScanType) > 0 {
ok := object.Key("scanType")
ok.String(string(v.ScanType))
}
return nil
}
type awsRestjson1_serializeOpSearchVulnerabilities struct {
}
func (*awsRestjson1_serializeOpSearchVulnerabilities) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpSearchVulnerabilities) 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.(*SearchVulnerabilitiesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/vulnerabilities/search")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentSearchVulnerabilitiesInput(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_serializeOpHttpBindingsSearchVulnerabilitiesInput(v *SearchVulnerabilitiesInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentSearchVulnerabilitiesInput(v *SearchVulnerabilitiesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FilterCriteria != nil {
ok := object.Key("filterCriteria")
if err := awsRestjson1_serializeDocumentSearchVulnerabilitiesFilterCriteria(v.FilterCriteria, ok); err != nil {
return err
}
}
if v.NextToken != nil {
ok := object.Key("nextToken")
ok.String(*v.NextToken)
}
return nil
}
type awsRestjson1_serializeOpTagResource struct {
}
func (*awsRestjson1_serializeOpTagResource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*TagResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")}
}
if v.ResourceArn != nil {
if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Tags != nil {
ok := object.Key("tags")
if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUntagResource struct {
}
func (*awsRestjson1_serializeOpUntagResource) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UntagResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "DELETE"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = restEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")}
}
if v.ResourceArn != nil {
if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil {
return err
}
}
if v.TagKeys != nil {
for i := range v.TagKeys {
encoder.AddQuery("tagKeys").String(v.TagKeys[i])
}
}
return nil
}
type awsRestjson1_serializeOpUpdateConfiguration struct {
}
func (*awsRestjson1_serializeOpUpdateConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateConfiguration) 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.(*UpdateConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/configuration/update")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateConfigurationInput(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_serializeOpHttpBindingsUpdateConfigurationInput(v *UpdateConfigurationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateConfigurationInput(v *UpdateConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.EcrConfiguration != nil {
ok := object.Key("ecrConfiguration")
if err := awsRestjson1_serializeDocumentEcrConfiguration(v.EcrConfiguration, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUpdateEc2DeepInspectionConfiguration struct {
}
func (*awsRestjson1_serializeOpUpdateEc2DeepInspectionConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateEc2DeepInspectionConfiguration) 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.(*UpdateEc2DeepInspectionConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/ec2deepinspectionconfiguration/update")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateEc2DeepInspectionConfigurationInput(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_serializeOpHttpBindingsUpdateEc2DeepInspectionConfigurationInput(v *UpdateEc2DeepInspectionConfigurationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateEc2DeepInspectionConfigurationInput(v *UpdateEc2DeepInspectionConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ActivateDeepInspection != nil {
ok := object.Key("activateDeepInspection")
ok.Boolean(*v.ActivateDeepInspection)
}
if v.PackagePaths != nil {
ok := object.Key("packagePaths")
if err := awsRestjson1_serializeDocumentPathList(v.PackagePaths, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUpdateEncryptionKey struct {
}
func (*awsRestjson1_serializeOpUpdateEncryptionKey) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateEncryptionKey) 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.(*UpdateEncryptionKeyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/encryptionkey/update")
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_serializeOpDocumentUpdateEncryptionKeyInput(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_serializeOpHttpBindingsUpdateEncryptionKeyInput(v *UpdateEncryptionKeyInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateEncryptionKeyInput(v *UpdateEncryptionKeyInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.KmsKeyId != nil {
ok := object.Key("kmsKeyId")
ok.String(*v.KmsKeyId)
}
if len(v.ResourceType) > 0 {
ok := object.Key("resourceType")
ok.String(string(v.ResourceType))
}
if len(v.ScanType) > 0 {
ok := object.Key("scanType")
ok.String(string(v.ScanType))
}
return nil
}
type awsRestjson1_serializeOpUpdateFilter struct {
}
func (*awsRestjson1_serializeOpUpdateFilter) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateFilter) 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.(*UpdateFilterInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/filters/update")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateFilterInput(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_serializeOpHttpBindingsUpdateFilterInput(v *UpdateFilterInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateFilterInput(v *UpdateFilterInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Action) > 0 {
ok := object.Key("action")
ok.String(string(v.Action))
}
if v.Description != nil {
ok := object.Key("description")
ok.String(*v.Description)
}
if v.FilterArn != nil {
ok := object.Key("filterArn")
ok.String(*v.FilterArn)
}
if v.FilterCriteria != nil {
ok := object.Key("filterCriteria")
if err := awsRestjson1_serializeDocumentFilterCriteria(v.FilterCriteria, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("name")
ok.String(*v.Name)
}
if v.Reason != nil {
ok := object.Key("reason")
ok.String(*v.Reason)
}
return nil
}
type awsRestjson1_serializeOpUpdateOrganizationConfiguration struct {
}
func (*awsRestjson1_serializeOpUpdateOrganizationConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateOrganizationConfiguration) 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.(*UpdateOrganizationConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/organizationconfiguration/update")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateOrganizationConfigurationInput(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_serializeOpHttpBindingsUpdateOrganizationConfigurationInput(v *UpdateOrganizationConfigurationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateOrganizationConfigurationInput(v *UpdateOrganizationConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AutoEnable != nil {
ok := object.Key("autoEnable")
if err := awsRestjson1_serializeDocumentAutoEnable(v.AutoEnable, ok); err != nil {
return err
}
}
return nil
}
type awsRestjson1_serializeOpUpdateOrgEc2DeepInspectionConfiguration struct {
}
func (*awsRestjson1_serializeOpUpdateOrgEc2DeepInspectionConfiguration) ID() string {
return "OperationSerializer"
}
func (m *awsRestjson1_serializeOpUpdateOrgEc2DeepInspectionConfiguration) 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.(*UpdateOrgEc2DeepInspectionConfigurationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
opPath, opQuery := httpbinding.SplitURI("/ec2deepinspectionconfiguration/org/update")
request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
request.Method = "POST"
restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
restEncoder.SetHeader("Content-Type").String("application/json")
jsonEncoder := smithyjson.NewEncoder()
if err := awsRestjson1_serializeOpDocumentUpdateOrgEc2DeepInspectionConfigurationInput(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_serializeOpHttpBindingsUpdateOrgEc2DeepInspectionConfigurationInput(v *UpdateOrgEc2DeepInspectionConfigurationInput, encoder *httpbinding.Encoder) error {
if v == nil {
return fmt.Errorf("unsupported serialization of nil %T", v)
}
return nil
}
func awsRestjson1_serializeOpDocumentUpdateOrgEc2DeepInspectionConfigurationInput(v *UpdateOrgEc2DeepInspectionConfigurationInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.OrgPackagePaths != nil {
ok := object.Key("orgPackagePaths")
if err := awsRestjson1_serializeDocumentPathList(v.OrgPackagePaths, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentAccountAggregation(v *types.AccountAggregation, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.FindingType) > 0 {
ok := object.Key("findingType")
ok.String(string(v.FindingType))
}
if len(v.ResourceType) > 0 {
ok := object.Key("resourceType")
ok.String(string(v.ResourceType))
}
if len(v.SortBy) > 0 {
ok := object.Key("sortBy")
ok.String(string(v.SortBy))
}
if len(v.SortOrder) > 0 {
ok := object.Key("sortOrder")
ok.String(string(v.SortOrder))
}
return nil
}
func awsRestjson1_serializeDocumentAccountIdSet(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsRestjson1_serializeDocumentAggregationRequest(v types.AggregationRequest, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
switch uv := v.(type) {
case *types.AggregationRequestMemberAccountAggregation:
av := object.Key("accountAggregation")
if err := awsRestjson1_serializeDocumentAccountAggregation(&uv.Value, av); err != nil {
return err
}
case *types.AggregationRequestMemberAmiAggregation:
av := object.Key("amiAggregation")
if err := awsRestjson1_serializeDocumentAmiAggregation(&uv.Value, av); err != nil {
return err
}
case *types.AggregationRequestMemberAwsEcrContainerAggregation:
av := object.Key("awsEcrContainerAggregation")
if err := awsRestjson1_serializeDocumentAwsEcrContainerAggregation(&uv.Value, av); err != nil {
return err
}
case *types.AggregationRequestMemberEc2InstanceAggregation:
av := object.Key("ec2InstanceAggregation")
if err := awsRestjson1_serializeDocumentEc2InstanceAggregation(&uv.Value, av); err != nil {
return err
}
case *types.AggregationRequestMemberFindingTypeAggregation:
av := object.Key("findingTypeAggregation")
if err := awsRestjson1_serializeDocumentFindingTypeAggregation(&uv.Value, av); err != nil {
return err
}
case *types.AggregationRequestMemberImageLayerAggregation:
av := object.Key("imageLayerAggregation")
if err := awsRestjson1_serializeDocumentImageLayerAggregation(&uv.Value, av); err != nil {
return err
}
case *types.AggregationRequestMemberLambdaFunctionAggregation:
av := object.Key("lambdaFunctionAggregation")
if err := awsRestjson1_serializeDocumentLambdaFunctionAggregation(&uv.Value, av); err != nil {
return err
}
case *types.AggregationRequestMemberLambdaLayerAggregation:
av := object.Key("lambdaLayerAggregation")
if err := awsRestjson1_serializeDocumentLambdaLayerAggregation(&uv.Value, av); err != nil {
return err
}
case *types.AggregationRequestMemberPackageAggregation:
av := object.Key("packageAggregation")
if err := awsRestjson1_serializeDocumentPackageAggregation(&uv.Value, av); err != nil {
return err
}
case *types.AggregationRequestMemberRepositoryAggregation:
av := object.Key("repositoryAggregation")
if err := awsRestjson1_serializeDocumentRepositoryAggregation(&uv.Value, av); err != nil {
return err
}
case *types.AggregationRequestMemberTitleAggregation:
av := object.Key("titleAggregation")
if err := awsRestjson1_serializeDocumentTitleAggregation(&uv.Value, av); err != nil {
return err
}
default:
return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
}
return nil
}
func awsRestjson1_serializeDocumentAmiAggregation(v *types.AmiAggregation, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Amis != nil {
ok := object.Key("amis")
if err := awsRestjson1_serializeDocumentStringFilterList(v.Amis, ok); err != nil {
return err
}
}
if len(v.SortBy) > 0 {
ok := object.Key("sortBy")
ok.String(string(v.SortBy))
}
if len(v.SortOrder) > 0 {
ok := object.Key("sortOrder")
ok.String(string(v.SortOrder))
}
return nil
}
func awsRestjson1_serializeDocumentAutoEnable(v *types.AutoEnable, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Ec2 != nil {
ok := object.Key("ec2")
ok.Boolean(*v.Ec2)
}
if v.Ecr != nil {
ok := object.Key("ecr")
ok.Boolean(*v.Ecr)
}
if v.Lambda != nil {
ok := object.Key("lambda")
ok.Boolean(*v.Lambda)
}
if v.LambdaCode != nil {
ok := object.Key("lambdaCode")
ok.Boolean(*v.LambdaCode)
}
return nil
}
func awsRestjson1_serializeDocumentAwsEcrContainerAggregation(v *types.AwsEcrContainerAggregation, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Architectures != nil {
ok := object.Key("architectures")
if err := awsRestjson1_serializeDocumentStringFilterList(v.Architectures, ok); err != nil {
return err
}
}
if v.ImageShas != nil {
ok := object.Key("imageShas")
if err := awsRestjson1_serializeDocumentStringFilterList(v.ImageShas, ok); err != nil {
return err
}
}
if v.ImageTags != nil {
ok := object.Key("imageTags")
if err := awsRestjson1_serializeDocumentStringFilterList(v.ImageTags, ok); err != nil {
return err
}
}
if v.Repositories != nil {
ok := object.Key("repositories")
if err := awsRestjson1_serializeDocumentStringFilterList(v.Repositories, ok); err != nil {
return err
}
}
if v.ResourceIds != nil {
ok := object.Key("resourceIds")
if err := awsRestjson1_serializeDocumentStringFilterList(v.ResourceIds, ok); err != nil {
return err
}
}
if len(v.SortBy) > 0 {
ok := object.Key("sortBy")
ok.String(string(v.SortBy))
}
if len(v.SortOrder) > 0 {
ok := object.Key("sortOrder")
ok.String(string(v.SortOrder))
}
return nil
}
func awsRestjson1_serializeDocumentCoverageDateFilter(v *types.CoverageDateFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.EndInclusive != nil {
ok := object.Key("endInclusive")
ok.Double(smithytime.FormatEpochSeconds(*v.EndInclusive))
}
if v.StartInclusive != nil {
ok := object.Key("startInclusive")
ok.Double(smithytime.FormatEpochSeconds(*v.StartInclusive))
}
return nil
}
func awsRestjson1_serializeDocumentCoverageDateFilterList(v []types.CoverageDateFilter, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentCoverageDateFilter(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentCoverageFilterCriteria(v *types.CoverageFilterCriteria, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccountId != nil {
ok := object.Key("accountId")
if err := awsRestjson1_serializeDocumentCoverageStringFilterList(v.AccountId, ok); err != nil {
return err
}
}
if v.Ec2InstanceTags != nil {
ok := object.Key("ec2InstanceTags")
if err := awsRestjson1_serializeDocumentCoverageMapFilterList(v.Ec2InstanceTags, ok); err != nil {
return err
}
}
if v.EcrImageTags != nil {
ok := object.Key("ecrImageTags")
if err := awsRestjson1_serializeDocumentCoverageStringFilterList(v.EcrImageTags, ok); err != nil {
return err
}
}
if v.EcrRepositoryName != nil {
ok := object.Key("ecrRepositoryName")
if err := awsRestjson1_serializeDocumentCoverageStringFilterList(v.EcrRepositoryName, ok); err != nil {
return err
}
}
if v.LambdaFunctionName != nil {
ok := object.Key("lambdaFunctionName")
if err := awsRestjson1_serializeDocumentCoverageStringFilterList(v.LambdaFunctionName, ok); err != nil {
return err
}
}
if v.LambdaFunctionRuntime != nil {
ok := object.Key("lambdaFunctionRuntime")
if err := awsRestjson1_serializeDocumentCoverageStringFilterList(v.LambdaFunctionRuntime, ok); err != nil {
return err
}
}
if v.LambdaFunctionTags != nil {
ok := object.Key("lambdaFunctionTags")
if err := awsRestjson1_serializeDocumentCoverageMapFilterList(v.LambdaFunctionTags, ok); err != nil {
return err
}
}
if v.LastScannedAt != nil {
ok := object.Key("lastScannedAt")
if err := awsRestjson1_serializeDocumentCoverageDateFilterList(v.LastScannedAt, ok); err != nil {
return err
}
}
if v.ResourceId != nil {
ok := object.Key("resourceId")
if err := awsRestjson1_serializeDocumentCoverageStringFilterList(v.ResourceId, ok); err != nil {
return err
}
}
if v.ResourceType != nil {
ok := object.Key("resourceType")
if err := awsRestjson1_serializeDocumentCoverageStringFilterList(v.ResourceType, ok); err != nil {
return err
}
}
if v.ScanStatusCode != nil {
ok := object.Key("scanStatusCode")
if err := awsRestjson1_serializeDocumentCoverageStringFilterList(v.ScanStatusCode, ok); err != nil {
return err
}
}
if v.ScanStatusReason != nil {
ok := object.Key("scanStatusReason")
if err := awsRestjson1_serializeDocumentCoverageStringFilterList(v.ScanStatusReason, ok); err != nil {
return err
}
}
if v.ScanType != nil {
ok := object.Key("scanType")
if err := awsRestjson1_serializeDocumentCoverageStringFilterList(v.ScanType, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentCoverageMapFilter(v *types.CoverageMapFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Comparison) > 0 {
ok := object.Key("comparison")
ok.String(string(v.Comparison))
}
if v.Key != nil {
ok := object.Key("key")
ok.String(*v.Key)
}
if v.Value != nil {
ok := object.Key("value")
ok.String(*v.Value)
}
return nil
}
func awsRestjson1_serializeDocumentCoverageMapFilterList(v []types.CoverageMapFilter, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentCoverageMapFilter(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentCoverageStringFilter(v *types.CoverageStringFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Comparison) > 0 {
ok := object.Key("comparison")
ok.String(string(v.Comparison))
}
if v.Value != nil {
ok := object.Key("value")
ok.String(*v.Value)
}
return nil
}
func awsRestjson1_serializeDocumentCoverageStringFilterList(v []types.CoverageStringFilter, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentCoverageStringFilter(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentDateFilter(v *types.DateFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.EndInclusive != nil {
ok := object.Key("endInclusive")
ok.Double(smithytime.FormatEpochSeconds(*v.EndInclusive))
}
if v.StartInclusive != nil {
ok := object.Key("startInclusive")
ok.Double(smithytime.FormatEpochSeconds(*v.StartInclusive))
}
return nil
}
func awsRestjson1_serializeDocumentDateFilterList(v []types.DateFilter, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentDateFilter(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentDestination(v *types.Destination, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.BucketName != nil {
ok := object.Key("bucketName")
ok.String(*v.BucketName)
}
if v.KeyPrefix != nil {
ok := object.Key("keyPrefix")
ok.String(*v.KeyPrefix)
}
if v.KmsKeyArn != nil {
ok := object.Key("kmsKeyArn")
ok.String(*v.KmsKeyArn)
}
return nil
}
func awsRestjson1_serializeDocumentDisableResourceTypeList(v []types.ResourceScanType, 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_serializeDocumentEc2InstanceAggregation(v *types.Ec2InstanceAggregation, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Amis != nil {
ok := object.Key("amis")
if err := awsRestjson1_serializeDocumentStringFilterList(v.Amis, ok); err != nil {
return err
}
}
if v.InstanceIds != nil {
ok := object.Key("instanceIds")
if err := awsRestjson1_serializeDocumentStringFilterList(v.InstanceIds, ok); err != nil {
return err
}
}
if v.InstanceTags != nil {
ok := object.Key("instanceTags")
if err := awsRestjson1_serializeDocumentMapFilterList(v.InstanceTags, ok); err != nil {
return err
}
}
if v.OperatingSystems != nil {
ok := object.Key("operatingSystems")
if err := awsRestjson1_serializeDocumentStringFilterList(v.OperatingSystems, ok); err != nil {
return err
}
}
if len(v.SortBy) > 0 {
ok := object.Key("sortBy")
ok.String(string(v.SortBy))
}
if len(v.SortOrder) > 0 {
ok := object.Key("sortOrder")
ok.String(string(v.SortOrder))
}
return nil
}
func awsRestjson1_serializeDocumentEcrConfiguration(v *types.EcrConfiguration, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.RescanDuration) > 0 {
ok := object.Key("rescanDuration")
ok.String(string(v.RescanDuration))
}
return nil
}
func awsRestjson1_serializeDocumentEnableResourceTypeList(v []types.ResourceScanType, 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_serializeDocumentFilterArnList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsRestjson1_serializeDocumentFilterCriteria(v *types.FilterCriteria, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AwsAccountId != nil {
ok := object.Key("awsAccountId")
if err := awsRestjson1_serializeDocumentStringFilterList(v.AwsAccountId, ok); err != nil {
return err
}
}
if v.CodeVulnerabilityDetectorName != nil {
ok := object.Key("codeVulnerabilityDetectorName")
if err := awsRestjson1_serializeDocumentStringFilterList(v.CodeVulnerabilityDetectorName, ok); err != nil {
return err
}
}
if v.CodeVulnerabilityDetectorTags != nil {
ok := object.Key("codeVulnerabilityDetectorTags")
if err := awsRestjson1_serializeDocumentStringFilterList(v.CodeVulnerabilityDetectorTags, ok); err != nil {
return err
}
}
if v.CodeVulnerabilityFilePath != nil {
ok := object.Key("codeVulnerabilityFilePath")
if err := awsRestjson1_serializeDocumentStringFilterList(v.CodeVulnerabilityFilePath, ok); err != nil {
return err
}
}
if v.ComponentId != nil {
ok := object.Key("componentId")
if err := awsRestjson1_serializeDocumentStringFilterList(v.ComponentId, ok); err != nil {
return err
}
}
if v.ComponentType != nil {
ok := object.Key("componentType")
if err := awsRestjson1_serializeDocumentStringFilterList(v.ComponentType, ok); err != nil {
return err
}
}
if v.Ec2InstanceImageId != nil {
ok := object.Key("ec2InstanceImageId")
if err := awsRestjson1_serializeDocumentStringFilterList(v.Ec2InstanceImageId, ok); err != nil {
return err
}
}
if v.Ec2InstanceSubnetId != nil {
ok := object.Key("ec2InstanceSubnetId")
if err := awsRestjson1_serializeDocumentStringFilterList(v.Ec2InstanceSubnetId, ok); err != nil {
return err
}
}
if v.Ec2InstanceVpcId != nil {
ok := object.Key("ec2InstanceVpcId")
if err := awsRestjson1_serializeDocumentStringFilterList(v.Ec2InstanceVpcId, ok); err != nil {
return err
}
}
if v.EcrImageArchitecture != nil {
ok := object.Key("ecrImageArchitecture")
if err := awsRestjson1_serializeDocumentStringFilterList(v.EcrImageArchitecture, ok); err != nil {
return err
}
}
if v.EcrImageHash != nil {
ok := object.Key("ecrImageHash")
if err := awsRestjson1_serializeDocumentStringFilterList(v.EcrImageHash, ok); err != nil {
return err
}
}
if v.EcrImagePushedAt != nil {
ok := object.Key("ecrImagePushedAt")
if err := awsRestjson1_serializeDocumentDateFilterList(v.EcrImagePushedAt, ok); err != nil {
return err
}
}
if v.EcrImageRegistry != nil {
ok := object.Key("ecrImageRegistry")
if err := awsRestjson1_serializeDocumentStringFilterList(v.EcrImageRegistry, ok); err != nil {
return err
}
}
if v.EcrImageRepositoryName != nil {
ok := object.Key("ecrImageRepositoryName")
if err := awsRestjson1_serializeDocumentStringFilterList(v.EcrImageRepositoryName, ok); err != nil {
return err
}
}
if v.EcrImageTags != nil {
ok := object.Key("ecrImageTags")
if err := awsRestjson1_serializeDocumentStringFilterList(v.EcrImageTags, ok); err != nil {
return err
}
}
if v.EpssScore != nil {
ok := object.Key("epssScore")
if err := awsRestjson1_serializeDocumentNumberFilterList(v.EpssScore, ok); err != nil {
return err
}
}
if v.ExploitAvailable != nil {
ok := object.Key("exploitAvailable")
if err := awsRestjson1_serializeDocumentStringFilterList(v.ExploitAvailable, ok); err != nil {
return err
}
}
if v.FindingArn != nil {
ok := object.Key("findingArn")
if err := awsRestjson1_serializeDocumentStringFilterList(v.FindingArn, ok); err != nil {
return err
}
}
if v.FindingStatus != nil {
ok := object.Key("findingStatus")
if err := awsRestjson1_serializeDocumentStringFilterList(v.FindingStatus, ok); err != nil {
return err
}
}
if v.FindingType != nil {
ok := object.Key("findingType")
if err := awsRestjson1_serializeDocumentStringFilterList(v.FindingType, ok); err != nil {
return err
}
}
if v.FirstObservedAt != nil {
ok := object.Key("firstObservedAt")
if err := awsRestjson1_serializeDocumentDateFilterList(v.FirstObservedAt, ok); err != nil {
return err
}
}
if v.FixAvailable != nil {
ok := object.Key("fixAvailable")
if err := awsRestjson1_serializeDocumentStringFilterList(v.FixAvailable, ok); err != nil {
return err
}
}
if v.InspectorScore != nil {
ok := object.Key("inspectorScore")
if err := awsRestjson1_serializeDocumentNumberFilterList(v.InspectorScore, ok); err != nil {
return err
}
}
if v.LambdaFunctionExecutionRoleArn != nil {
ok := object.Key("lambdaFunctionExecutionRoleArn")
if err := awsRestjson1_serializeDocumentStringFilterList(v.LambdaFunctionExecutionRoleArn, ok); err != nil {
return err
}
}
if v.LambdaFunctionLastModifiedAt != nil {
ok := object.Key("lambdaFunctionLastModifiedAt")
if err := awsRestjson1_serializeDocumentDateFilterList(v.LambdaFunctionLastModifiedAt, ok); err != nil {
return err
}
}
if v.LambdaFunctionLayers != nil {
ok := object.Key("lambdaFunctionLayers")
if err := awsRestjson1_serializeDocumentStringFilterList(v.LambdaFunctionLayers, ok); err != nil {
return err
}
}
if v.LambdaFunctionName != nil {
ok := object.Key("lambdaFunctionName")
if err := awsRestjson1_serializeDocumentStringFilterList(v.LambdaFunctionName, ok); err != nil {
return err
}
}
if v.LambdaFunctionRuntime != nil {
ok := object.Key("lambdaFunctionRuntime")
if err := awsRestjson1_serializeDocumentStringFilterList(v.LambdaFunctionRuntime, ok); err != nil {
return err
}
}
if v.LastObservedAt != nil {
ok := object.Key("lastObservedAt")
if err := awsRestjson1_serializeDocumentDateFilterList(v.LastObservedAt, ok); err != nil {
return err
}
}
if v.NetworkProtocol != nil {
ok := object.Key("networkProtocol")
if err := awsRestjson1_serializeDocumentStringFilterList(v.NetworkProtocol, ok); err != nil {
return err
}
}
if v.PortRange != nil {
ok := object.Key("portRange")
if err := awsRestjson1_serializeDocumentPortRangeFilterList(v.PortRange, ok); err != nil {
return err
}
}
if v.RelatedVulnerabilities != nil {
ok := object.Key("relatedVulnerabilities")
if err := awsRestjson1_serializeDocumentStringFilterList(v.RelatedVulnerabilities, ok); err != nil {
return err
}
}
if v.ResourceId != nil {
ok := object.Key("resourceId")
if err := awsRestjson1_serializeDocumentStringFilterList(v.ResourceId, ok); err != nil {
return err
}
}
if v.ResourceTags != nil {
ok := object.Key("resourceTags")
if err := awsRestjson1_serializeDocumentMapFilterList(v.ResourceTags, ok); err != nil {
return err
}
}
if v.ResourceType != nil {
ok := object.Key("resourceType")
if err := awsRestjson1_serializeDocumentStringFilterList(v.ResourceType, ok); err != nil {
return err
}
}
if v.Severity != nil {
ok := object.Key("severity")
if err := awsRestjson1_serializeDocumentStringFilterList(v.Severity, ok); err != nil {
return err
}
}
if v.Title != nil {
ok := object.Key("title")
if err := awsRestjson1_serializeDocumentStringFilterList(v.Title, ok); err != nil {
return err
}
}
if v.UpdatedAt != nil {
ok := object.Key("updatedAt")
if err := awsRestjson1_serializeDocumentDateFilterList(v.UpdatedAt, ok); err != nil {
return err
}
}
if v.VendorSeverity != nil {
ok := object.Key("vendorSeverity")
if err := awsRestjson1_serializeDocumentStringFilterList(v.VendorSeverity, ok); err != nil {
return err
}
}
if v.VulnerabilityId != nil {
ok := object.Key("vulnerabilityId")
if err := awsRestjson1_serializeDocumentStringFilterList(v.VulnerabilityId, ok); err != nil {
return err
}
}
if v.VulnerabilitySource != nil {
ok := object.Key("vulnerabilitySource")
if err := awsRestjson1_serializeDocumentStringFilterList(v.VulnerabilitySource, ok); err != nil {
return err
}
}
if v.VulnerablePackages != nil {
ok := object.Key("vulnerablePackages")
if err := awsRestjson1_serializeDocumentPackageFilterList(v.VulnerablePackages, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentFindingArns(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsRestjson1_serializeDocumentFindingTypeAggregation(v *types.FindingTypeAggregation, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.FindingType) > 0 {
ok := object.Key("findingType")
ok.String(string(v.FindingType))
}
if len(v.ResourceType) > 0 {
ok := object.Key("resourceType")
ok.String(string(v.ResourceType))
}
if len(v.SortBy) > 0 {
ok := object.Key("sortBy")
ok.String(string(v.SortBy))
}
if len(v.SortOrder) > 0 {
ok := object.Key("sortOrder")
ok.String(string(v.SortOrder))
}
return nil
}
func awsRestjson1_serializeDocumentImageLayerAggregation(v *types.ImageLayerAggregation, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LayerHashes != nil {
ok := object.Key("layerHashes")
if err := awsRestjson1_serializeDocumentStringFilterList(v.LayerHashes, ok); err != nil {
return err
}
}
if v.Repositories != nil {
ok := object.Key("repositories")
if err := awsRestjson1_serializeDocumentStringFilterList(v.Repositories, ok); err != nil {
return err
}
}
if v.ResourceIds != nil {
ok := object.Key("resourceIds")
if err := awsRestjson1_serializeDocumentStringFilterList(v.ResourceIds, ok); err != nil {
return err
}
}
if len(v.SortBy) > 0 {
ok := object.Key("sortBy")
ok.String(string(v.SortBy))
}
if len(v.SortOrder) > 0 {
ok := object.Key("sortOrder")
ok.String(string(v.SortOrder))
}
return nil
}
func awsRestjson1_serializeDocumentLambdaFunctionAggregation(v *types.LambdaFunctionAggregation, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FunctionNames != nil {
ok := object.Key("functionNames")
if err := awsRestjson1_serializeDocumentStringFilterList(v.FunctionNames, ok); err != nil {
return err
}
}
if v.FunctionTags != nil {
ok := object.Key("functionTags")
if err := awsRestjson1_serializeDocumentMapFilterList(v.FunctionTags, ok); err != nil {
return err
}
}
if v.ResourceIds != nil {
ok := object.Key("resourceIds")
if err := awsRestjson1_serializeDocumentStringFilterList(v.ResourceIds, ok); err != nil {
return err
}
}
if v.Runtimes != nil {
ok := object.Key("runtimes")
if err := awsRestjson1_serializeDocumentStringFilterList(v.Runtimes, ok); err != nil {
return err
}
}
if len(v.SortBy) > 0 {
ok := object.Key("sortBy")
ok.String(string(v.SortBy))
}
if len(v.SortOrder) > 0 {
ok := object.Key("sortOrder")
ok.String(string(v.SortOrder))
}
return nil
}
func awsRestjson1_serializeDocumentLambdaLayerAggregation(v *types.LambdaLayerAggregation, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.FunctionNames != nil {
ok := object.Key("functionNames")
if err := awsRestjson1_serializeDocumentStringFilterList(v.FunctionNames, ok); err != nil {
return err
}
}
if v.LayerArns != nil {
ok := object.Key("layerArns")
if err := awsRestjson1_serializeDocumentStringFilterList(v.LayerArns, ok); err != nil {
return err
}
}
if v.ResourceIds != nil {
ok := object.Key("resourceIds")
if err := awsRestjson1_serializeDocumentStringFilterList(v.ResourceIds, ok); err != nil {
return err
}
}
if len(v.SortBy) > 0 {
ok := object.Key("sortBy")
ok.String(string(v.SortBy))
}
if len(v.SortOrder) > 0 {
ok := object.Key("sortOrder")
ok.String(string(v.SortOrder))
}
return nil
}
func awsRestjson1_serializeDocumentMapFilter(v *types.MapFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Comparison) > 0 {
ok := object.Key("comparison")
ok.String(string(v.Comparison))
}
if v.Key != nil {
ok := object.Key("key")
ok.String(*v.Key)
}
if v.Value != nil {
ok := object.Key("value")
ok.String(*v.Value)
}
return nil
}
func awsRestjson1_serializeDocumentMapFilterList(v []types.MapFilter, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentMapFilter(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentMemberAccountEc2DeepInspectionStatus(v *types.MemberAccountEc2DeepInspectionStatus, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccountId != nil {
ok := object.Key("accountId")
ok.String(*v.AccountId)
}
if v.ActivateDeepInspection != nil {
ok := object.Key("activateDeepInspection")
ok.Boolean(*v.ActivateDeepInspection)
}
return nil
}
func awsRestjson1_serializeDocumentMemberAccountEc2DeepInspectionStatusList(v []types.MemberAccountEc2DeepInspectionStatus, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentMemberAccountEc2DeepInspectionStatus(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentMeteringAccountIdList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsRestjson1_serializeDocumentNumberFilter(v *types.NumberFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.LowerInclusive != nil {
ok := object.Key("lowerInclusive")
switch {
case math.IsNaN(*v.LowerInclusive):
ok.String("NaN")
case math.IsInf(*v.LowerInclusive, 1):
ok.String("Infinity")
case math.IsInf(*v.LowerInclusive, -1):
ok.String("-Infinity")
default:
ok.Double(*v.LowerInclusive)
}
}
if v.UpperInclusive != nil {
ok := object.Key("upperInclusive")
switch {
case math.IsNaN(*v.UpperInclusive):
ok.String("NaN")
case math.IsInf(*v.UpperInclusive, 1):
ok.String("Infinity")
case math.IsInf(*v.UpperInclusive, -1):
ok.String("-Infinity")
default:
ok.Double(*v.UpperInclusive)
}
}
return nil
}
func awsRestjson1_serializeDocumentNumberFilterList(v []types.NumberFilter, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentNumberFilter(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentPackageAggregation(v *types.PackageAggregation, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.PackageNames != nil {
ok := object.Key("packageNames")
if err := awsRestjson1_serializeDocumentStringFilterList(v.PackageNames, ok); err != nil {
return err
}
}
if len(v.SortBy) > 0 {
ok := object.Key("sortBy")
ok.String(string(v.SortBy))
}
if len(v.SortOrder) > 0 {
ok := object.Key("sortOrder")
ok.String(string(v.SortOrder))
}
return nil
}
func awsRestjson1_serializeDocumentPackageFilter(v *types.PackageFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Architecture != nil {
ok := object.Key("architecture")
if err := awsRestjson1_serializeDocumentStringFilter(v.Architecture, ok); err != nil {
return err
}
}
if v.Epoch != nil {
ok := object.Key("epoch")
if err := awsRestjson1_serializeDocumentNumberFilter(v.Epoch, ok); err != nil {
return err
}
}
if v.Name != nil {
ok := object.Key("name")
if err := awsRestjson1_serializeDocumentStringFilter(v.Name, ok); err != nil {
return err
}
}
if v.Release != nil {
ok := object.Key("release")
if err := awsRestjson1_serializeDocumentStringFilter(v.Release, ok); err != nil {
return err
}
}
if v.SourceLambdaLayerArn != nil {
ok := object.Key("sourceLambdaLayerArn")
if err := awsRestjson1_serializeDocumentStringFilter(v.SourceLambdaLayerArn, ok); err != nil {
return err
}
}
if v.SourceLayerHash != nil {
ok := object.Key("sourceLayerHash")
if err := awsRestjson1_serializeDocumentStringFilter(v.SourceLayerHash, ok); err != nil {
return err
}
}
if v.Version != nil {
ok := object.Key("version")
if err := awsRestjson1_serializeDocumentStringFilter(v.Version, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentPackageFilterList(v []types.PackageFilter, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentPackageFilter(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentPathList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsRestjson1_serializeDocumentPortRangeFilter(v *types.PortRangeFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.BeginInclusive != nil {
ok := object.Key("beginInclusive")
ok.Integer(*v.BeginInclusive)
}
if v.EndInclusive != nil {
ok := object.Key("endInclusive")
ok.Integer(*v.EndInclusive)
}
return nil
}
func awsRestjson1_serializeDocumentPortRangeFilterList(v []types.PortRangeFilter, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentPortRangeFilter(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentRepositoryAggregation(v *types.RepositoryAggregation, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Repositories != nil {
ok := object.Key("repositories")
if err := awsRestjson1_serializeDocumentStringFilterList(v.Repositories, ok); err != nil {
return err
}
}
if len(v.SortBy) > 0 {
ok := object.Key("sortBy")
ok.String(string(v.SortBy))
}
if len(v.SortOrder) > 0 {
ok := object.Key("sortOrder")
ok.String(string(v.SortOrder))
}
return nil
}
func awsRestjson1_serializeDocumentResourceFilterCriteria(v *types.ResourceFilterCriteria, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccountId != nil {
ok := object.Key("accountId")
if err := awsRestjson1_serializeDocumentResourceStringFilterList(v.AccountId, ok); err != nil {
return err
}
}
if v.Ec2InstanceTags != nil {
ok := object.Key("ec2InstanceTags")
if err := awsRestjson1_serializeDocumentResourceMapFilterList(v.Ec2InstanceTags, ok); err != nil {
return err
}
}
if v.EcrImageTags != nil {
ok := object.Key("ecrImageTags")
if err := awsRestjson1_serializeDocumentResourceStringFilterList(v.EcrImageTags, ok); err != nil {
return err
}
}
if v.EcrRepositoryName != nil {
ok := object.Key("ecrRepositoryName")
if err := awsRestjson1_serializeDocumentResourceStringFilterList(v.EcrRepositoryName, ok); err != nil {
return err
}
}
if v.LambdaFunctionName != nil {
ok := object.Key("lambdaFunctionName")
if err := awsRestjson1_serializeDocumentResourceStringFilterList(v.LambdaFunctionName, ok); err != nil {
return err
}
}
if v.LambdaFunctionTags != nil {
ok := object.Key("lambdaFunctionTags")
if err := awsRestjson1_serializeDocumentResourceMapFilterList(v.LambdaFunctionTags, ok); err != nil {
return err
}
}
if v.ResourceId != nil {
ok := object.Key("resourceId")
if err := awsRestjson1_serializeDocumentResourceStringFilterList(v.ResourceId, ok); err != nil {
return err
}
}
if v.ResourceType != nil {
ok := object.Key("resourceType")
if err := awsRestjson1_serializeDocumentResourceStringFilterList(v.ResourceType, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentResourceMapFilter(v *types.ResourceMapFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Comparison) > 0 {
ok := object.Key("comparison")
ok.String(string(v.Comparison))
}
if v.Key != nil {
ok := object.Key("key")
ok.String(*v.Key)
}
if v.Value != nil {
ok := object.Key("value")
ok.String(*v.Value)
}
return nil
}
func awsRestjson1_serializeDocumentResourceMapFilterList(v []types.ResourceMapFilter, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentResourceMapFilter(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentResourceStringFilter(v *types.ResourceStringFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Comparison) > 0 {
ok := object.Key("comparison")
ok.String(string(v.Comparison))
}
if v.Value != nil {
ok := object.Key("value")
ok.String(*v.Value)
}
return nil
}
func awsRestjson1_serializeDocumentResourceStringFilterList(v []types.ResourceStringFilter, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentResourceStringFilter(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentSearchVulnerabilitiesFilterCriteria(v *types.SearchVulnerabilitiesFilterCriteria, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.VulnerabilityIds != nil {
ok := object.Key("vulnerabilityIds")
if err := awsRestjson1_serializeDocumentVulnIdList(v.VulnerabilityIds, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentSortCriteria(v *types.SortCriteria, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Field) > 0 {
ok := object.Key("field")
ok.String(string(v.Field))
}
if len(v.SortOrder) > 0 {
ok := object.Key("sortOrder")
ok.String(string(v.SortOrder))
}
return nil
}
func awsRestjson1_serializeDocumentStringFilter(v *types.StringFilter, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.Comparison) > 0 {
ok := object.Key("comparison")
ok.String(string(v.Comparison))
}
if v.Value != nil {
ok := object.Key("value")
ok.String(*v.Value)
}
return nil
}
func awsRestjson1_serializeDocumentStringFilterList(v []types.StringFilter, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsRestjson1_serializeDocumentStringFilter(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentTagMap(v map[string]string, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
om.String(v[key])
}
return nil
}
func awsRestjson1_serializeDocumentTitleAggregation(v *types.TitleAggregation, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.FindingType) > 0 {
ok := object.Key("findingType")
ok.String(string(v.FindingType))
}
if len(v.ResourceType) > 0 {
ok := object.Key("resourceType")
ok.String(string(v.ResourceType))
}
if len(v.SortBy) > 0 {
ok := object.Key("sortBy")
ok.String(string(v.SortBy))
}
if len(v.SortOrder) > 0 {
ok := object.Key("sortOrder")
ok.String(string(v.SortOrder))
}
if v.Titles != nil {
ok := object.Key("titles")
if err := awsRestjson1_serializeDocumentStringFilterList(v.Titles, ok); err != nil {
return err
}
}
if v.VulnerabilityIds != nil {
ok := object.Key("vulnerabilityIds")
if err := awsRestjson1_serializeDocumentStringFilterList(v.VulnerabilityIds, ok); err != nil {
return err
}
}
return nil
}
func awsRestjson1_serializeDocumentUsageAccountIdList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsRestjson1_serializeDocumentVulnIdList(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
}
| 4,821 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package inspector2
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/inspector2/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpAssociateMember struct {
}
func (*validateOpAssociateMember) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAssociateMember) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AssociateMemberInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAssociateMemberInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpBatchGetCodeSnippet struct {
}
func (*validateOpBatchGetCodeSnippet) ID() string {
return "OperationInputValidation"
}
func (m *validateOpBatchGetCodeSnippet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*BatchGetCodeSnippetInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpBatchGetCodeSnippetInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpBatchGetFreeTrialInfo struct {
}
func (*validateOpBatchGetFreeTrialInfo) ID() string {
return "OperationInputValidation"
}
func (m *validateOpBatchGetFreeTrialInfo) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*BatchGetFreeTrialInfoInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpBatchGetFreeTrialInfoInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpBatchUpdateMemberEc2DeepInspectionStatus struct {
}
func (*validateOpBatchUpdateMemberEc2DeepInspectionStatus) ID() string {
return "OperationInputValidation"
}
func (m *validateOpBatchUpdateMemberEc2DeepInspectionStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*BatchUpdateMemberEc2DeepInspectionStatusInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpBatchUpdateMemberEc2DeepInspectionStatusInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCancelFindingsReport struct {
}
func (*validateOpCancelFindingsReport) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCancelFindingsReport) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CancelFindingsReportInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCancelFindingsReportInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCancelSbomExport struct {
}
func (*validateOpCancelSbomExport) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCancelSbomExport) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CancelSbomExportInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCancelSbomExportInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateFilter struct {
}
func (*validateOpCreateFilter) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateFilter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateFilterInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateFilterInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateFindingsReport struct {
}
func (*validateOpCreateFindingsReport) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateFindingsReport) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateFindingsReportInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateFindingsReportInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateSbomExport struct {
}
func (*validateOpCreateSbomExport) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateSbomExport) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateSbomExportInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateSbomExportInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteFilter struct {
}
func (*validateOpDeleteFilter) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteFilter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteFilterInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteFilterInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDisableDelegatedAdminAccount struct {
}
func (*validateOpDisableDelegatedAdminAccount) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDisableDelegatedAdminAccount) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DisableDelegatedAdminAccountInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDisableDelegatedAdminAccountInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDisassociateMember struct {
}
func (*validateOpDisassociateMember) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDisassociateMember) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DisassociateMemberInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDisassociateMemberInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpEnableDelegatedAdminAccount struct {
}
func (*validateOpEnableDelegatedAdminAccount) ID() string {
return "OperationInputValidation"
}
func (m *validateOpEnableDelegatedAdminAccount) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*EnableDelegatedAdminAccountInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpEnableDelegatedAdminAccountInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpEnable struct {
}
func (*validateOpEnable) ID() string {
return "OperationInputValidation"
}
func (m *validateOpEnable) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*EnableInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpEnableInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetEncryptionKey struct {
}
func (*validateOpGetEncryptionKey) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetEncryptionKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetEncryptionKeyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetEncryptionKeyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetMember struct {
}
func (*validateOpGetMember) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetMember) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetMemberInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetMemberInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetSbomExport struct {
}
func (*validateOpGetSbomExport) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetSbomExport) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetSbomExportInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetSbomExportInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListCoverage struct {
}
func (*validateOpListCoverage) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListCoverage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListCoverageInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListCoverageInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListCoverageStatistics struct {
}
func (*validateOpListCoverageStatistics) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListCoverageStatistics) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListCoverageStatisticsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListCoverageStatisticsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListFindingAggregations struct {
}
func (*validateOpListFindingAggregations) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListFindingAggregations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListFindingAggregationsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListFindingAggregationsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListFindings struct {
}
func (*validateOpListFindings) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListFindings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListFindingsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListFindingsInput(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 validateOpResetEncryptionKey struct {
}
func (*validateOpResetEncryptionKey) ID() string {
return "OperationInputValidation"
}
func (m *validateOpResetEncryptionKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ResetEncryptionKeyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpResetEncryptionKeyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpSearchVulnerabilities struct {
}
func (*validateOpSearchVulnerabilities) ID() string {
return "OperationInputValidation"
}
func (m *validateOpSearchVulnerabilities) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*SearchVulnerabilitiesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpSearchVulnerabilitiesInput(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 validateOpUpdateConfiguration struct {
}
func (*validateOpUpdateConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateEncryptionKey struct {
}
func (*validateOpUpdateEncryptionKey) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateEncryptionKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateEncryptionKeyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateEncryptionKeyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateFilter struct {
}
func (*validateOpUpdateFilter) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateFilter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateFilterInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateFilterInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateOrganizationConfiguration struct {
}
func (*validateOpUpdateOrganizationConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateOrganizationConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateOrganizationConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateOrganizationConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateOrgEc2DeepInspectionConfiguration struct {
}
func (*validateOpUpdateOrgEc2DeepInspectionConfiguration) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateOrgEc2DeepInspectionConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateOrgEc2DeepInspectionConfigurationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateOrgEc2DeepInspectionConfigurationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpAssociateMemberValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAssociateMember{}, middleware.After)
}
func addOpBatchGetCodeSnippetValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpBatchGetCodeSnippet{}, middleware.After)
}
func addOpBatchGetFreeTrialInfoValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpBatchGetFreeTrialInfo{}, middleware.After)
}
func addOpBatchUpdateMemberEc2DeepInspectionStatusValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpBatchUpdateMemberEc2DeepInspectionStatus{}, middleware.After)
}
func addOpCancelFindingsReportValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCancelFindingsReport{}, middleware.After)
}
func addOpCancelSbomExportValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCancelSbomExport{}, middleware.After)
}
func addOpCreateFilterValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateFilter{}, middleware.After)
}
func addOpCreateFindingsReportValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateFindingsReport{}, middleware.After)
}
func addOpCreateSbomExportValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateSbomExport{}, middleware.After)
}
func addOpDeleteFilterValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteFilter{}, middleware.After)
}
func addOpDisableDelegatedAdminAccountValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDisableDelegatedAdminAccount{}, middleware.After)
}
func addOpDisassociateMemberValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDisassociateMember{}, middleware.After)
}
func addOpEnableDelegatedAdminAccountValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpEnableDelegatedAdminAccount{}, middleware.After)
}
func addOpEnableValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpEnable{}, middleware.After)
}
func addOpGetEncryptionKeyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetEncryptionKey{}, middleware.After)
}
func addOpGetMemberValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetMember{}, middleware.After)
}
func addOpGetSbomExportValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetSbomExport{}, middleware.After)
}
func addOpListCoverageValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListCoverage{}, middleware.After)
}
func addOpListCoverageStatisticsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListCoverageStatistics{}, middleware.After)
}
func addOpListFindingAggregationsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListFindingAggregations{}, middleware.After)
}
func addOpListFindingsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListFindings{}, middleware.After)
}
func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
}
func addOpResetEncryptionKeyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpResetEncryptionKey{}, middleware.After)
}
func addOpSearchVulnerabilitiesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpSearchVulnerabilities{}, 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 addOpUpdateConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateConfiguration{}, middleware.After)
}
func addOpUpdateEncryptionKeyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateEncryptionKey{}, middleware.After)
}
func addOpUpdateFilterValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateFilter{}, middleware.After)
}
func addOpUpdateOrganizationConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateOrganizationConfiguration{}, middleware.After)
}
func addOpUpdateOrgEc2DeepInspectionConfigurationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateOrgEc2DeepInspectionConfiguration{}, middleware.After)
}
func validateAggregationRequest(v types.AggregationRequest) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AggregationRequest"}
switch uv := v.(type) {
case *types.AggregationRequestMemberAmiAggregation:
if err := validateAmiAggregation(&uv.Value); err != nil {
invalidParams.AddNested("[amiAggregation]", err.(smithy.InvalidParamsError))
}
case *types.AggregationRequestMemberAwsEcrContainerAggregation:
if err := validateAwsEcrContainerAggregation(&uv.Value); err != nil {
invalidParams.AddNested("[awsEcrContainerAggregation]", err.(smithy.InvalidParamsError))
}
case *types.AggregationRequestMemberEc2InstanceAggregation:
if err := validateEc2InstanceAggregation(&uv.Value); err != nil {
invalidParams.AddNested("[ec2InstanceAggregation]", err.(smithy.InvalidParamsError))
}
case *types.AggregationRequestMemberImageLayerAggregation:
if err := validateImageLayerAggregation(&uv.Value); err != nil {
invalidParams.AddNested("[imageLayerAggregation]", err.(smithy.InvalidParamsError))
}
case *types.AggregationRequestMemberLambdaFunctionAggregation:
if err := validateLambdaFunctionAggregation(&uv.Value); err != nil {
invalidParams.AddNested("[lambdaFunctionAggregation]", err.(smithy.InvalidParamsError))
}
case *types.AggregationRequestMemberLambdaLayerAggregation:
if err := validateLambdaLayerAggregation(&uv.Value); err != nil {
invalidParams.AddNested("[lambdaLayerAggregation]", err.(smithy.InvalidParamsError))
}
case *types.AggregationRequestMemberPackageAggregation:
if err := validatePackageAggregation(&uv.Value); err != nil {
invalidParams.AddNested("[packageAggregation]", err.(smithy.InvalidParamsError))
}
case *types.AggregationRequestMemberRepositoryAggregation:
if err := validateRepositoryAggregation(&uv.Value); err != nil {
invalidParams.AddNested("[repositoryAggregation]", err.(smithy.InvalidParamsError))
}
case *types.AggregationRequestMemberTitleAggregation:
if err := validateTitleAggregation(&uv.Value); err != nil {
invalidParams.AddNested("[titleAggregation]", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAmiAggregation(v *types.AmiAggregation) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AmiAggregation"}
if v.Amis != nil {
if err := validateStringFilterList(v.Amis); err != nil {
invalidParams.AddNested("Amis", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAutoEnable(v *types.AutoEnable) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AutoEnable"}
if v.Ec2 == nil {
invalidParams.Add(smithy.NewErrParamRequired("Ec2"))
}
if v.Ecr == nil {
invalidParams.Add(smithy.NewErrParamRequired("Ecr"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAwsEcrContainerAggregation(v *types.AwsEcrContainerAggregation) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AwsEcrContainerAggregation"}
if v.ResourceIds != nil {
if err := validateStringFilterList(v.ResourceIds); err != nil {
invalidParams.AddNested("ResourceIds", err.(smithy.InvalidParamsError))
}
}
if v.ImageShas != nil {
if err := validateStringFilterList(v.ImageShas); err != nil {
invalidParams.AddNested("ImageShas", err.(smithy.InvalidParamsError))
}
}
if v.Repositories != nil {
if err := validateStringFilterList(v.Repositories); err != nil {
invalidParams.AddNested("Repositories", err.(smithy.InvalidParamsError))
}
}
if v.Architectures != nil {
if err := validateStringFilterList(v.Architectures); err != nil {
invalidParams.AddNested("Architectures", err.(smithy.InvalidParamsError))
}
}
if v.ImageTags != nil {
if err := validateStringFilterList(v.ImageTags); err != nil {
invalidParams.AddNested("ImageTags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCoverageFilterCriteria(v *types.CoverageFilterCriteria) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CoverageFilterCriteria"}
if v.ScanStatusCode != nil {
if err := validateCoverageStringFilterList(v.ScanStatusCode); err != nil {
invalidParams.AddNested("ScanStatusCode", err.(smithy.InvalidParamsError))
}
}
if v.ScanStatusReason != nil {
if err := validateCoverageStringFilterList(v.ScanStatusReason); err != nil {
invalidParams.AddNested("ScanStatusReason", err.(smithy.InvalidParamsError))
}
}
if v.AccountId != nil {
if err := validateCoverageStringFilterList(v.AccountId); err != nil {
invalidParams.AddNested("AccountId", err.(smithy.InvalidParamsError))
}
}
if v.ResourceId != nil {
if err := validateCoverageStringFilterList(v.ResourceId); err != nil {
invalidParams.AddNested("ResourceId", err.(smithy.InvalidParamsError))
}
}
if v.ResourceType != nil {
if err := validateCoverageStringFilterList(v.ResourceType); err != nil {
invalidParams.AddNested("ResourceType", err.(smithy.InvalidParamsError))
}
}
if v.ScanType != nil {
if err := validateCoverageStringFilterList(v.ScanType); err != nil {
invalidParams.AddNested("ScanType", err.(smithy.InvalidParamsError))
}
}
if v.EcrRepositoryName != nil {
if err := validateCoverageStringFilterList(v.EcrRepositoryName); err != nil {
invalidParams.AddNested("EcrRepositoryName", err.(smithy.InvalidParamsError))
}
}
if v.EcrImageTags != nil {
if err := validateCoverageStringFilterList(v.EcrImageTags); err != nil {
invalidParams.AddNested("EcrImageTags", err.(smithy.InvalidParamsError))
}
}
if v.Ec2InstanceTags != nil {
if err := validateCoverageMapFilterList(v.Ec2InstanceTags); err != nil {
invalidParams.AddNested("Ec2InstanceTags", err.(smithy.InvalidParamsError))
}
}
if v.LambdaFunctionName != nil {
if err := validateCoverageStringFilterList(v.LambdaFunctionName); err != nil {
invalidParams.AddNested("LambdaFunctionName", err.(smithy.InvalidParamsError))
}
}
if v.LambdaFunctionTags != nil {
if err := validateCoverageMapFilterList(v.LambdaFunctionTags); err != nil {
invalidParams.AddNested("LambdaFunctionTags", err.(smithy.InvalidParamsError))
}
}
if v.LambdaFunctionRuntime != nil {
if err := validateCoverageStringFilterList(v.LambdaFunctionRuntime); err != nil {
invalidParams.AddNested("LambdaFunctionRuntime", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCoverageMapFilter(v *types.CoverageMapFilter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CoverageMapFilter"}
if len(v.Comparison) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Comparison"))
}
if v.Key == nil {
invalidParams.Add(smithy.NewErrParamRequired("Key"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCoverageMapFilterList(v []types.CoverageMapFilter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CoverageMapFilterList"}
for i := range v {
if err := validateCoverageMapFilter(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCoverageStringFilter(v *types.CoverageStringFilter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CoverageStringFilter"}
if len(v.Comparison) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Comparison"))
}
if v.Value == nil {
invalidParams.Add(smithy.NewErrParamRequired("Value"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCoverageStringFilterList(v []types.CoverageStringFilter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CoverageStringFilterList"}
for i := range v {
if err := validateCoverageStringFilter(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateDestination(v *types.Destination) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Destination"}
if v.BucketName == nil {
invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
}
if v.KmsKeyArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("KmsKeyArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateEc2InstanceAggregation(v *types.Ec2InstanceAggregation) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Ec2InstanceAggregation"}
if v.Amis != nil {
if err := validateStringFilterList(v.Amis); err != nil {
invalidParams.AddNested("Amis", err.(smithy.InvalidParamsError))
}
}
if v.OperatingSystems != nil {
if err := validateStringFilterList(v.OperatingSystems); err != nil {
invalidParams.AddNested("OperatingSystems", err.(smithy.InvalidParamsError))
}
}
if v.InstanceIds != nil {
if err := validateStringFilterList(v.InstanceIds); err != nil {
invalidParams.AddNested("InstanceIds", err.(smithy.InvalidParamsError))
}
}
if v.InstanceTags != nil {
if err := validateMapFilterList(v.InstanceTags); err != nil {
invalidParams.AddNested("InstanceTags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateEcrConfiguration(v *types.EcrConfiguration) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "EcrConfiguration"}
if len(v.RescanDuration) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("RescanDuration"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateFilterCriteria(v *types.FilterCriteria) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "FilterCriteria"}
if v.FindingArn != nil {
if err := validateStringFilterList(v.FindingArn); err != nil {
invalidParams.AddNested("FindingArn", err.(smithy.InvalidParamsError))
}
}
if v.AwsAccountId != nil {
if err := validateStringFilterList(v.AwsAccountId); err != nil {
invalidParams.AddNested("AwsAccountId", err.(smithy.InvalidParamsError))
}
}
if v.FindingType != nil {
if err := validateStringFilterList(v.FindingType); err != nil {
invalidParams.AddNested("FindingType", err.(smithy.InvalidParamsError))
}
}
if v.Severity != nil {
if err := validateStringFilterList(v.Severity); err != nil {
invalidParams.AddNested("Severity", err.(smithy.InvalidParamsError))
}
}
if v.FindingStatus != nil {
if err := validateStringFilterList(v.FindingStatus); err != nil {
invalidParams.AddNested("FindingStatus", err.(smithy.InvalidParamsError))
}
}
if v.Title != nil {
if err := validateStringFilterList(v.Title); err != nil {
invalidParams.AddNested("Title", err.(smithy.InvalidParamsError))
}
}
if v.ResourceType != nil {
if err := validateStringFilterList(v.ResourceType); err != nil {
invalidParams.AddNested("ResourceType", err.(smithy.InvalidParamsError))
}
}
if v.ResourceId != nil {
if err := validateStringFilterList(v.ResourceId); err != nil {
invalidParams.AddNested("ResourceId", err.(smithy.InvalidParamsError))
}
}
if v.ResourceTags != nil {
if err := validateMapFilterList(v.ResourceTags); err != nil {
invalidParams.AddNested("ResourceTags", err.(smithy.InvalidParamsError))
}
}
if v.Ec2InstanceImageId != nil {
if err := validateStringFilterList(v.Ec2InstanceImageId); err != nil {
invalidParams.AddNested("Ec2InstanceImageId", err.(smithy.InvalidParamsError))
}
}
if v.Ec2InstanceVpcId != nil {
if err := validateStringFilterList(v.Ec2InstanceVpcId); err != nil {
invalidParams.AddNested("Ec2InstanceVpcId", err.(smithy.InvalidParamsError))
}
}
if v.Ec2InstanceSubnetId != nil {
if err := validateStringFilterList(v.Ec2InstanceSubnetId); err != nil {
invalidParams.AddNested("Ec2InstanceSubnetId", err.(smithy.InvalidParamsError))
}
}
if v.EcrImageArchitecture != nil {
if err := validateStringFilterList(v.EcrImageArchitecture); err != nil {
invalidParams.AddNested("EcrImageArchitecture", err.(smithy.InvalidParamsError))
}
}
if v.EcrImageRegistry != nil {
if err := validateStringFilterList(v.EcrImageRegistry); err != nil {
invalidParams.AddNested("EcrImageRegistry", err.(smithy.InvalidParamsError))
}
}
if v.EcrImageRepositoryName != nil {
if err := validateStringFilterList(v.EcrImageRepositoryName); err != nil {
invalidParams.AddNested("EcrImageRepositoryName", err.(smithy.InvalidParamsError))
}
}
if v.EcrImageTags != nil {
if err := validateStringFilterList(v.EcrImageTags); err != nil {
invalidParams.AddNested("EcrImageTags", err.(smithy.InvalidParamsError))
}
}
if v.EcrImageHash != nil {
if err := validateStringFilterList(v.EcrImageHash); err != nil {
invalidParams.AddNested("EcrImageHash", err.(smithy.InvalidParamsError))
}
}
if v.NetworkProtocol != nil {
if err := validateStringFilterList(v.NetworkProtocol); err != nil {
invalidParams.AddNested("NetworkProtocol", err.(smithy.InvalidParamsError))
}
}
if v.ComponentId != nil {
if err := validateStringFilterList(v.ComponentId); err != nil {
invalidParams.AddNested("ComponentId", err.(smithy.InvalidParamsError))
}
}
if v.ComponentType != nil {
if err := validateStringFilterList(v.ComponentType); err != nil {
invalidParams.AddNested("ComponentType", err.(smithy.InvalidParamsError))
}
}
if v.VulnerabilityId != nil {
if err := validateStringFilterList(v.VulnerabilityId); err != nil {
invalidParams.AddNested("VulnerabilityId", err.(smithy.InvalidParamsError))
}
}
if v.VulnerabilitySource != nil {
if err := validateStringFilterList(v.VulnerabilitySource); err != nil {
invalidParams.AddNested("VulnerabilitySource", err.(smithy.InvalidParamsError))
}
}
if v.VendorSeverity != nil {
if err := validateStringFilterList(v.VendorSeverity); err != nil {
invalidParams.AddNested("VendorSeverity", err.(smithy.InvalidParamsError))
}
}
if v.VulnerablePackages != nil {
if err := validatePackageFilterList(v.VulnerablePackages); err != nil {
invalidParams.AddNested("VulnerablePackages", err.(smithy.InvalidParamsError))
}
}
if v.RelatedVulnerabilities != nil {
if err := validateStringFilterList(v.RelatedVulnerabilities); err != nil {
invalidParams.AddNested("RelatedVulnerabilities", err.(smithy.InvalidParamsError))
}
}
if v.FixAvailable != nil {
if err := validateStringFilterList(v.FixAvailable); err != nil {
invalidParams.AddNested("FixAvailable", err.(smithy.InvalidParamsError))
}
}
if v.LambdaFunctionName != nil {
if err := validateStringFilterList(v.LambdaFunctionName); err != nil {
invalidParams.AddNested("LambdaFunctionName", err.(smithy.InvalidParamsError))
}
}
if v.LambdaFunctionLayers != nil {
if err := validateStringFilterList(v.LambdaFunctionLayers); err != nil {
invalidParams.AddNested("LambdaFunctionLayers", err.(smithy.InvalidParamsError))
}
}
if v.LambdaFunctionRuntime != nil {
if err := validateStringFilterList(v.LambdaFunctionRuntime); err != nil {
invalidParams.AddNested("LambdaFunctionRuntime", err.(smithy.InvalidParamsError))
}
}
if v.LambdaFunctionExecutionRoleArn != nil {
if err := validateStringFilterList(v.LambdaFunctionExecutionRoleArn); err != nil {
invalidParams.AddNested("LambdaFunctionExecutionRoleArn", err.(smithy.InvalidParamsError))
}
}
if v.ExploitAvailable != nil {
if err := validateStringFilterList(v.ExploitAvailable); err != nil {
invalidParams.AddNested("ExploitAvailable", err.(smithy.InvalidParamsError))
}
}
if v.CodeVulnerabilityDetectorName != nil {
if err := validateStringFilterList(v.CodeVulnerabilityDetectorName); err != nil {
invalidParams.AddNested("CodeVulnerabilityDetectorName", err.(smithy.InvalidParamsError))
}
}
if v.CodeVulnerabilityDetectorTags != nil {
if err := validateStringFilterList(v.CodeVulnerabilityDetectorTags); err != nil {
invalidParams.AddNested("CodeVulnerabilityDetectorTags", err.(smithy.InvalidParamsError))
}
}
if v.CodeVulnerabilityFilePath != nil {
if err := validateStringFilterList(v.CodeVulnerabilityFilePath); err != nil {
invalidParams.AddNested("CodeVulnerabilityFilePath", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateImageLayerAggregation(v *types.ImageLayerAggregation) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ImageLayerAggregation"}
if v.Repositories != nil {
if err := validateStringFilterList(v.Repositories); err != nil {
invalidParams.AddNested("Repositories", err.(smithy.InvalidParamsError))
}
}
if v.ResourceIds != nil {
if err := validateStringFilterList(v.ResourceIds); err != nil {
invalidParams.AddNested("ResourceIds", err.(smithy.InvalidParamsError))
}
}
if v.LayerHashes != nil {
if err := validateStringFilterList(v.LayerHashes); err != nil {
invalidParams.AddNested("LayerHashes", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateLambdaFunctionAggregation(v *types.LambdaFunctionAggregation) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "LambdaFunctionAggregation"}
if v.ResourceIds != nil {
if err := validateStringFilterList(v.ResourceIds); err != nil {
invalidParams.AddNested("ResourceIds", err.(smithy.InvalidParamsError))
}
}
if v.FunctionNames != nil {
if err := validateStringFilterList(v.FunctionNames); err != nil {
invalidParams.AddNested("FunctionNames", err.(smithy.InvalidParamsError))
}
}
if v.Runtimes != nil {
if err := validateStringFilterList(v.Runtimes); err != nil {
invalidParams.AddNested("Runtimes", err.(smithy.InvalidParamsError))
}
}
if v.FunctionTags != nil {
if err := validateMapFilterList(v.FunctionTags); err != nil {
invalidParams.AddNested("FunctionTags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateLambdaLayerAggregation(v *types.LambdaLayerAggregation) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "LambdaLayerAggregation"}
if v.FunctionNames != nil {
if err := validateStringFilterList(v.FunctionNames); err != nil {
invalidParams.AddNested("FunctionNames", err.(smithy.InvalidParamsError))
}
}
if v.ResourceIds != nil {
if err := validateStringFilterList(v.ResourceIds); err != nil {
invalidParams.AddNested("ResourceIds", err.(smithy.InvalidParamsError))
}
}
if v.LayerArns != nil {
if err := validateStringFilterList(v.LayerArns); err != nil {
invalidParams.AddNested("LayerArns", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateMapFilter(v *types.MapFilter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "MapFilter"}
if len(v.Comparison) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Comparison"))
}
if v.Key == nil {
invalidParams.Add(smithy.NewErrParamRequired("Key"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateMapFilterList(v []types.MapFilter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "MapFilterList"}
for i := range v {
if err := validateMapFilter(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateMemberAccountEc2DeepInspectionStatus(v *types.MemberAccountEc2DeepInspectionStatus) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "MemberAccountEc2DeepInspectionStatus"}
if v.AccountId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
}
if v.ActivateDeepInspection == nil {
invalidParams.Add(smithy.NewErrParamRequired("ActivateDeepInspection"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateMemberAccountEc2DeepInspectionStatusList(v []types.MemberAccountEc2DeepInspectionStatus) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "MemberAccountEc2DeepInspectionStatusList"}
for i := range v {
if err := validateMemberAccountEc2DeepInspectionStatus(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validatePackageAggregation(v *types.PackageAggregation) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PackageAggregation"}
if v.PackageNames != nil {
if err := validateStringFilterList(v.PackageNames); err != nil {
invalidParams.AddNested("PackageNames", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validatePackageFilter(v *types.PackageFilter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PackageFilter"}
if v.Name != nil {
if err := validateStringFilter(v.Name); err != nil {
invalidParams.AddNested("Name", err.(smithy.InvalidParamsError))
}
}
if v.Version != nil {
if err := validateStringFilter(v.Version); err != nil {
invalidParams.AddNested("Version", err.(smithy.InvalidParamsError))
}
}
if v.Release != nil {
if err := validateStringFilter(v.Release); err != nil {
invalidParams.AddNested("Release", err.(smithy.InvalidParamsError))
}
}
if v.Architecture != nil {
if err := validateStringFilter(v.Architecture); err != nil {
invalidParams.AddNested("Architecture", err.(smithy.InvalidParamsError))
}
}
if v.SourceLayerHash != nil {
if err := validateStringFilter(v.SourceLayerHash); err != nil {
invalidParams.AddNested("SourceLayerHash", err.(smithy.InvalidParamsError))
}
}
if v.SourceLambdaLayerArn != nil {
if err := validateStringFilter(v.SourceLambdaLayerArn); err != nil {
invalidParams.AddNested("SourceLambdaLayerArn", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validatePackageFilterList(v []types.PackageFilter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PackageFilterList"}
for i := range v {
if err := validatePackageFilter(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateRepositoryAggregation(v *types.RepositoryAggregation) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RepositoryAggregation"}
if v.Repositories != nil {
if err := validateStringFilterList(v.Repositories); err != nil {
invalidParams.AddNested("Repositories", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateResourceFilterCriteria(v *types.ResourceFilterCriteria) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ResourceFilterCriteria"}
if v.AccountId != nil {
if err := validateResourceStringFilterList(v.AccountId); err != nil {
invalidParams.AddNested("AccountId", err.(smithy.InvalidParamsError))
}
}
if v.ResourceId != nil {
if err := validateResourceStringFilterList(v.ResourceId); err != nil {
invalidParams.AddNested("ResourceId", err.(smithy.InvalidParamsError))
}
}
if v.ResourceType != nil {
if err := validateResourceStringFilterList(v.ResourceType); err != nil {
invalidParams.AddNested("ResourceType", err.(smithy.InvalidParamsError))
}
}
if v.EcrRepositoryName != nil {
if err := validateResourceStringFilterList(v.EcrRepositoryName); err != nil {
invalidParams.AddNested("EcrRepositoryName", err.(smithy.InvalidParamsError))
}
}
if v.LambdaFunctionName != nil {
if err := validateResourceStringFilterList(v.LambdaFunctionName); err != nil {
invalidParams.AddNested("LambdaFunctionName", err.(smithy.InvalidParamsError))
}
}
if v.EcrImageTags != nil {
if err := validateResourceStringFilterList(v.EcrImageTags); err != nil {
invalidParams.AddNested("EcrImageTags", err.(smithy.InvalidParamsError))
}
}
if v.Ec2InstanceTags != nil {
if err := validateResourceMapFilterList(v.Ec2InstanceTags); err != nil {
invalidParams.AddNested("Ec2InstanceTags", err.(smithy.InvalidParamsError))
}
}
if v.LambdaFunctionTags != nil {
if err := validateResourceMapFilterList(v.LambdaFunctionTags); err != nil {
invalidParams.AddNested("LambdaFunctionTags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateResourceMapFilter(v *types.ResourceMapFilter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ResourceMapFilter"}
if len(v.Comparison) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Comparison"))
}
if v.Key == nil {
invalidParams.Add(smithy.NewErrParamRequired("Key"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateResourceMapFilterList(v []types.ResourceMapFilter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ResourceMapFilterList"}
for i := range v {
if err := validateResourceMapFilter(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateResourceStringFilter(v *types.ResourceStringFilter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ResourceStringFilter"}
if len(v.Comparison) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Comparison"))
}
if v.Value == nil {
invalidParams.Add(smithy.NewErrParamRequired("Value"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateResourceStringFilterList(v []types.ResourceStringFilter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ResourceStringFilterList"}
for i := range v {
if err := validateResourceStringFilter(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSearchVulnerabilitiesFilterCriteria(v *types.SearchVulnerabilitiesFilterCriteria) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SearchVulnerabilitiesFilterCriteria"}
if v.VulnerabilityIds == nil {
invalidParams.Add(smithy.NewErrParamRequired("VulnerabilityIds"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSortCriteria(v *types.SortCriteria) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SortCriteria"}
if len(v.Field) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Field"))
}
if len(v.SortOrder) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("SortOrder"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateStringFilter(v *types.StringFilter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StringFilter"}
if len(v.Comparison) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Comparison"))
}
if v.Value == nil {
invalidParams.Add(smithy.NewErrParamRequired("Value"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateStringFilterList(v []types.StringFilter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StringFilterList"}
for i := range v {
if err := validateStringFilter(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTitleAggregation(v *types.TitleAggregation) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TitleAggregation"}
if v.Titles != nil {
if err := validateStringFilterList(v.Titles); err != nil {
invalidParams.AddNested("Titles", err.(smithy.InvalidParamsError))
}
}
if v.VulnerabilityIds != nil {
if err := validateStringFilterList(v.VulnerabilityIds); err != nil {
invalidParams.AddNested("VulnerabilityIds", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAssociateMemberInput(v *AssociateMemberInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AssociateMemberInput"}
if v.AccountId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpBatchGetCodeSnippetInput(v *BatchGetCodeSnippetInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchGetCodeSnippetInput"}
if v.FindingArns == nil {
invalidParams.Add(smithy.NewErrParamRequired("FindingArns"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpBatchGetFreeTrialInfoInput(v *BatchGetFreeTrialInfoInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchGetFreeTrialInfoInput"}
if v.AccountIds == nil {
invalidParams.Add(smithy.NewErrParamRequired("AccountIds"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpBatchUpdateMemberEc2DeepInspectionStatusInput(v *BatchUpdateMemberEc2DeepInspectionStatusInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchUpdateMemberEc2DeepInspectionStatusInput"}
if v.AccountIds == nil {
invalidParams.Add(smithy.NewErrParamRequired("AccountIds"))
} else if v.AccountIds != nil {
if err := validateMemberAccountEc2DeepInspectionStatusList(v.AccountIds); err != nil {
invalidParams.AddNested("AccountIds", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCancelFindingsReportInput(v *CancelFindingsReportInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CancelFindingsReportInput"}
if v.ReportId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ReportId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCancelSbomExportInput(v *CancelSbomExportInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CancelSbomExportInput"}
if v.ReportId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ReportId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateFilterInput(v *CreateFilterInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateFilterInput"}
if len(v.Action) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Action"))
}
if v.FilterCriteria == nil {
invalidParams.Add(smithy.NewErrParamRequired("FilterCriteria"))
} else if v.FilterCriteria != nil {
if err := validateFilterCriteria(v.FilterCriteria); err != nil {
invalidParams.AddNested("FilterCriteria", err.(smithy.InvalidParamsError))
}
}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateFindingsReportInput(v *CreateFindingsReportInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateFindingsReportInput"}
if v.FilterCriteria != nil {
if err := validateFilterCriteria(v.FilterCriteria); err != nil {
invalidParams.AddNested("FilterCriteria", err.(smithy.InvalidParamsError))
}
}
if len(v.ReportFormat) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ReportFormat"))
}
if v.S3Destination == nil {
invalidParams.Add(smithy.NewErrParamRequired("S3Destination"))
} else if v.S3Destination != nil {
if err := validateDestination(v.S3Destination); err != nil {
invalidParams.AddNested("S3Destination", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateSbomExportInput(v *CreateSbomExportInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateSbomExportInput"}
if v.ResourceFilterCriteria != nil {
if err := validateResourceFilterCriteria(v.ResourceFilterCriteria); err != nil {
invalidParams.AddNested("ResourceFilterCriteria", err.(smithy.InvalidParamsError))
}
}
if len(v.ReportFormat) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ReportFormat"))
}
if v.S3Destination == nil {
invalidParams.Add(smithy.NewErrParamRequired("S3Destination"))
} else if v.S3Destination != nil {
if err := validateDestination(v.S3Destination); err != nil {
invalidParams.AddNested("S3Destination", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteFilterInput(v *DeleteFilterInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteFilterInput"}
if v.Arn == nil {
invalidParams.Add(smithy.NewErrParamRequired("Arn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDisableDelegatedAdminAccountInput(v *DisableDelegatedAdminAccountInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DisableDelegatedAdminAccountInput"}
if v.DelegatedAdminAccountId == nil {
invalidParams.Add(smithy.NewErrParamRequired("DelegatedAdminAccountId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDisassociateMemberInput(v *DisassociateMemberInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DisassociateMemberInput"}
if v.AccountId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpEnableDelegatedAdminAccountInput(v *EnableDelegatedAdminAccountInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "EnableDelegatedAdminAccountInput"}
if v.DelegatedAdminAccountId == nil {
invalidParams.Add(smithy.NewErrParamRequired("DelegatedAdminAccountId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpEnableInput(v *EnableInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "EnableInput"}
if v.ResourceTypes == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceTypes"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetEncryptionKeyInput(v *GetEncryptionKeyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetEncryptionKeyInput"}
if len(v.ScanType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ScanType"))
}
if len(v.ResourceType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetMemberInput(v *GetMemberInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetMemberInput"}
if v.AccountId == nil {
invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetSbomExportInput(v *GetSbomExportInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetSbomExportInput"}
if v.ReportId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ReportId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListCoverageInput(v *ListCoverageInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListCoverageInput"}
if v.FilterCriteria != nil {
if err := validateCoverageFilterCriteria(v.FilterCriteria); err != nil {
invalidParams.AddNested("FilterCriteria", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListCoverageStatisticsInput(v *ListCoverageStatisticsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListCoverageStatisticsInput"}
if v.FilterCriteria != nil {
if err := validateCoverageFilterCriteria(v.FilterCriteria); err != nil {
invalidParams.AddNested("FilterCriteria", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListFindingAggregationsInput(v *ListFindingAggregationsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListFindingAggregationsInput"}
if len(v.AggregationType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("AggregationType"))
}
if v.AccountIds != nil {
if err := validateStringFilterList(v.AccountIds); err != nil {
invalidParams.AddNested("AccountIds", err.(smithy.InvalidParamsError))
}
}
if v.AggregationRequest != nil {
if err := validateAggregationRequest(v.AggregationRequest); err != nil {
invalidParams.AddNested("AggregationRequest", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListFindingsInput(v *ListFindingsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListFindingsInput"}
if v.FilterCriteria != nil {
if err := validateFilterCriteria(v.FilterCriteria); err != nil {
invalidParams.AddNested("FilterCriteria", err.(smithy.InvalidParamsError))
}
}
if v.SortCriteria != nil {
if err := validateSortCriteria(v.SortCriteria); err != nil {
invalidParams.AddNested("SortCriteria", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpResetEncryptionKeyInput(v *ResetEncryptionKeyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ResetEncryptionKeyInput"}
if len(v.ScanType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ScanType"))
}
if len(v.ResourceType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpSearchVulnerabilitiesInput(v *SearchVulnerabilitiesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SearchVulnerabilitiesInput"}
if v.FilterCriteria == nil {
invalidParams.Add(smithy.NewErrParamRequired("FilterCriteria"))
} else if v.FilterCriteria != nil {
if err := validateSearchVulnerabilitiesFilterCriteria(v.FilterCriteria); err != nil {
invalidParams.AddNested("FilterCriteria", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpTagResourceInput(v *TagResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if v.Tags == nil {
invalidParams.Add(smithy.NewErrParamRequired("Tags"))
}
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 validateOpUpdateConfigurationInput(v *UpdateConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateConfigurationInput"}
if v.EcrConfiguration == nil {
invalidParams.Add(smithy.NewErrParamRequired("EcrConfiguration"))
} else if v.EcrConfiguration != nil {
if err := validateEcrConfiguration(v.EcrConfiguration); err != nil {
invalidParams.AddNested("EcrConfiguration", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateEncryptionKeyInput(v *UpdateEncryptionKeyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateEncryptionKeyInput"}
if v.KmsKeyId == nil {
invalidParams.Add(smithy.NewErrParamRequired("KmsKeyId"))
}
if len(v.ScanType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ScanType"))
}
if len(v.ResourceType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateFilterInput(v *UpdateFilterInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateFilterInput"}
if v.FilterCriteria != nil {
if err := validateFilterCriteria(v.FilterCriteria); err != nil {
invalidParams.AddNested("FilterCriteria", err.(smithy.InvalidParamsError))
}
}
if v.FilterArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("FilterArn"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateOrganizationConfigurationInput(v *UpdateOrganizationConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateOrganizationConfigurationInput"}
if v.AutoEnable == nil {
invalidParams.Add(smithy.NewErrParamRequired("AutoEnable"))
} else if v.AutoEnable != nil {
if err := validateAutoEnable(v.AutoEnable); err != nil {
invalidParams.AddNested("AutoEnable", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateOrgEc2DeepInspectionConfigurationInput(v *UpdateOrgEc2DeepInspectionConfigurationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateOrgEc2DeepInspectionConfigurationInput"}
if v.OrgPackagePaths == nil {
invalidParams.Add(smithy.NewErrParamRequired("OrgPackagePaths"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 2,296 |
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 Inspector2 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: "inspector2.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "inspector2-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "inspector2-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "inspector2.{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: "me-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "sa-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-east-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-west-2",
}: endpoints.Endpoint{},
},
},
{
ID: "aws-cn",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "inspector2.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "inspector2-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "inspector2-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "inspector2.{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: "inspector2-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "inspector2.{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: "inspector2-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "inspector2.{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: "inspector2-fips.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "inspector2.{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: "inspector2-fips.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "inspector2.{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: "inspector2.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "inspector2-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "inspector2-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "inspector2.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "us-gov-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-gov-west-1",
}: endpoints.Endpoint{},
},
},
}
| 364 |
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 AccountSortBy string
// Enum values for AccountSortBy
const (
AccountSortByCritical AccountSortBy = "CRITICAL"
AccountSortByHigh AccountSortBy = "HIGH"
AccountSortByAll AccountSortBy = "ALL"
)
// Values returns all known values for AccountSortBy. 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 (AccountSortBy) Values() []AccountSortBy {
return []AccountSortBy{
"CRITICAL",
"HIGH",
"ALL",
}
}
type AggregationFindingType string
// Enum values for AggregationFindingType
const (
AggregationFindingTypeNetworkReachability AggregationFindingType = "NETWORK_REACHABILITY"
AggregationFindingTypePackageVulnerability AggregationFindingType = "PACKAGE_VULNERABILITY"
AggregationFindingTypeCodeVulnerability AggregationFindingType = "CODE_VULNERABILITY"
)
// Values returns all known values for AggregationFindingType. 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 (AggregationFindingType) Values() []AggregationFindingType {
return []AggregationFindingType{
"NETWORK_REACHABILITY",
"PACKAGE_VULNERABILITY",
"CODE_VULNERABILITY",
}
}
type AggregationResourceType string
// Enum values for AggregationResourceType
const (
AggregationResourceTypeAwsEc2Instance AggregationResourceType = "AWS_EC2_INSTANCE"
AggregationResourceTypeAwsEcrContainerImage AggregationResourceType = "AWS_ECR_CONTAINER_IMAGE"
AggregationResourceTypeAwsLambdaFunction AggregationResourceType = "AWS_LAMBDA_FUNCTION"
)
// Values returns all known values for AggregationResourceType. 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 (AggregationResourceType) Values() []AggregationResourceType {
return []AggregationResourceType{
"AWS_EC2_INSTANCE",
"AWS_ECR_CONTAINER_IMAGE",
"AWS_LAMBDA_FUNCTION",
}
}
type AggregationType string
// Enum values for AggregationType
const (
AggregationTypeFindingType AggregationType = "FINDING_TYPE"
AggregationTypePackage AggregationType = "PACKAGE"
AggregationTypeTitle AggregationType = "TITLE"
AggregationTypeRepository AggregationType = "REPOSITORY"
AggregationTypeAmi AggregationType = "AMI"
AggregationTypeAwsEc2Instance AggregationType = "AWS_EC2_INSTANCE"
AggregationTypeAwsEcrContainer AggregationType = "AWS_ECR_CONTAINER"
AggregationTypeImageLayer AggregationType = "IMAGE_LAYER"
AggregationTypeAccount AggregationType = "ACCOUNT"
AggregationTypeAwsLambdaFunction AggregationType = "AWS_LAMBDA_FUNCTION"
AggregationTypeLambdaLayer AggregationType = "LAMBDA_LAYER"
)
// Values returns all known values for AggregationType. 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 (AggregationType) Values() []AggregationType {
return []AggregationType{
"FINDING_TYPE",
"PACKAGE",
"TITLE",
"REPOSITORY",
"AMI",
"AWS_EC2_INSTANCE",
"AWS_ECR_CONTAINER",
"IMAGE_LAYER",
"ACCOUNT",
"AWS_LAMBDA_FUNCTION",
"LAMBDA_LAYER",
}
}
type AmiSortBy string
// Enum values for AmiSortBy
const (
AmiSortByCritical AmiSortBy = "CRITICAL"
AmiSortByHigh AmiSortBy = "HIGH"
AmiSortByAll AmiSortBy = "ALL"
AmiSortByAffectedInstances AmiSortBy = "AFFECTED_INSTANCES"
)
// Values returns all known values for AmiSortBy. 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 (AmiSortBy) Values() []AmiSortBy {
return []AmiSortBy{
"CRITICAL",
"HIGH",
"ALL",
"AFFECTED_INSTANCES",
}
}
type Architecture string
// Enum values for Architecture
const (
ArchitectureX8664 Architecture = "X86_64"
ArchitectureArm64 Architecture = "ARM64"
)
// Values returns all known values for Architecture. 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 (Architecture) Values() []Architecture {
return []Architecture{
"X86_64",
"ARM64",
}
}
type AwsEcrContainerSortBy string
// Enum values for AwsEcrContainerSortBy
const (
AwsEcrContainerSortByCritical AwsEcrContainerSortBy = "CRITICAL"
AwsEcrContainerSortByHigh AwsEcrContainerSortBy = "HIGH"
AwsEcrContainerSortByAll AwsEcrContainerSortBy = "ALL"
)
// Values returns all known values for AwsEcrContainerSortBy. 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 (AwsEcrContainerSortBy) Values() []AwsEcrContainerSortBy {
return []AwsEcrContainerSortBy{
"CRITICAL",
"HIGH",
"ALL",
}
}
type CodeSnippetErrorCode string
// Enum values for CodeSnippetErrorCode
const (
CodeSnippetErrorCodeInternalError CodeSnippetErrorCode = "INTERNAL_ERROR"
CodeSnippetErrorCodeAccessDenied CodeSnippetErrorCode = "ACCESS_DENIED"
CodeSnippetErrorCodeCodeSnippetNotFound CodeSnippetErrorCode = "CODE_SNIPPET_NOT_FOUND"
CodeSnippetErrorCodeInvalidInput CodeSnippetErrorCode = "INVALID_INPUT"
)
// Values returns all known values for CodeSnippetErrorCode. 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 (CodeSnippetErrorCode) Values() []CodeSnippetErrorCode {
return []CodeSnippetErrorCode{
"INTERNAL_ERROR",
"ACCESS_DENIED",
"CODE_SNIPPET_NOT_FOUND",
"INVALID_INPUT",
}
}
type CoverageMapComparison string
// Enum values for CoverageMapComparison
const (
CoverageMapComparisonEquals CoverageMapComparison = "EQUALS"
)
// Values returns all known values for CoverageMapComparison. 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 (CoverageMapComparison) Values() []CoverageMapComparison {
return []CoverageMapComparison{
"EQUALS",
}
}
type CoverageResourceType string
// Enum values for CoverageResourceType
const (
CoverageResourceTypeAwsEc2Instance CoverageResourceType = "AWS_EC2_INSTANCE"
CoverageResourceTypeAwsEcrContainerImage CoverageResourceType = "AWS_ECR_CONTAINER_IMAGE"
CoverageResourceTypeAwsEcrRepository CoverageResourceType = "AWS_ECR_REPOSITORY"
CoverageResourceTypeAwsLambdaFunction CoverageResourceType = "AWS_LAMBDA_FUNCTION"
)
// Values returns all known values for CoverageResourceType. 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 (CoverageResourceType) Values() []CoverageResourceType {
return []CoverageResourceType{
"AWS_EC2_INSTANCE",
"AWS_ECR_CONTAINER_IMAGE",
"AWS_ECR_REPOSITORY",
"AWS_LAMBDA_FUNCTION",
}
}
type CoverageStringComparison string
// Enum values for CoverageStringComparison
const (
CoverageStringComparisonEquals CoverageStringComparison = "EQUALS"
CoverageStringComparisonNotEquals CoverageStringComparison = "NOT_EQUALS"
)
// Values returns all known values for CoverageStringComparison. 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 (CoverageStringComparison) Values() []CoverageStringComparison {
return []CoverageStringComparison{
"EQUALS",
"NOT_EQUALS",
}
}
type Currency string
// Enum values for Currency
const (
CurrencyUsd Currency = "USD"
)
// Values returns all known values for Currency. 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 (Currency) Values() []Currency {
return []Currency{
"USD",
}
}
type DelegatedAdminStatus string
// Enum values for DelegatedAdminStatus
const (
DelegatedAdminStatusEnabled DelegatedAdminStatus = "ENABLED"
DelegatedAdminStatusDisableInProgress DelegatedAdminStatus = "DISABLE_IN_PROGRESS"
)
// Values returns all known values for DelegatedAdminStatus. 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 (DelegatedAdminStatus) Values() []DelegatedAdminStatus {
return []DelegatedAdminStatus{
"ENABLED",
"DISABLE_IN_PROGRESS",
}
}
type Ec2DeepInspectionStatus string
// Enum values for Ec2DeepInspectionStatus
const (
Ec2DeepInspectionStatusActivated Ec2DeepInspectionStatus = "ACTIVATED"
Ec2DeepInspectionStatusDeactivated Ec2DeepInspectionStatus = "DEACTIVATED"
Ec2DeepInspectionStatusPending Ec2DeepInspectionStatus = "PENDING"
Ec2DeepInspectionStatusFailed Ec2DeepInspectionStatus = "FAILED"
)
// Values returns all known values for Ec2DeepInspectionStatus. 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 (Ec2DeepInspectionStatus) Values() []Ec2DeepInspectionStatus {
return []Ec2DeepInspectionStatus{
"ACTIVATED",
"DEACTIVATED",
"PENDING",
"FAILED",
}
}
type Ec2InstanceSortBy string
// Enum values for Ec2InstanceSortBy
const (
Ec2InstanceSortByNetworkFindings Ec2InstanceSortBy = "NETWORK_FINDINGS"
Ec2InstanceSortByCritical Ec2InstanceSortBy = "CRITICAL"
Ec2InstanceSortByHigh Ec2InstanceSortBy = "HIGH"
Ec2InstanceSortByAll Ec2InstanceSortBy = "ALL"
)
// Values returns all known values for Ec2InstanceSortBy. 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 (Ec2InstanceSortBy) Values() []Ec2InstanceSortBy {
return []Ec2InstanceSortBy{
"NETWORK_FINDINGS",
"CRITICAL",
"HIGH",
"ALL",
}
}
type Ec2Platform string
// Enum values for Ec2Platform
const (
Ec2PlatformWindows Ec2Platform = "WINDOWS"
Ec2PlatformLinux Ec2Platform = "LINUX"
Ec2PlatformUnknown Ec2Platform = "UNKNOWN"
)
// Values returns all known values for Ec2Platform. 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 (Ec2Platform) Values() []Ec2Platform {
return []Ec2Platform{
"WINDOWS",
"LINUX",
"UNKNOWN",
}
}
type EcrRescanDuration string
// Enum values for EcrRescanDuration
const (
EcrRescanDurationLifetime EcrRescanDuration = "LIFETIME"
EcrRescanDurationDays30 EcrRescanDuration = "DAYS_30"
EcrRescanDurationDays180 EcrRescanDuration = "DAYS_180"
)
// Values returns all known values for EcrRescanDuration. 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 (EcrRescanDuration) Values() []EcrRescanDuration {
return []EcrRescanDuration{
"LIFETIME",
"DAYS_30",
"DAYS_180",
}
}
type EcrRescanDurationStatus string
// Enum values for EcrRescanDurationStatus
const (
EcrRescanDurationStatusSuccess EcrRescanDurationStatus = "SUCCESS"
EcrRescanDurationStatusPending EcrRescanDurationStatus = "PENDING"
EcrRescanDurationStatusFailed EcrRescanDurationStatus = "FAILED"
)
// Values returns all known values for EcrRescanDurationStatus. 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 (EcrRescanDurationStatus) Values() []EcrRescanDurationStatus {
return []EcrRescanDurationStatus{
"SUCCESS",
"PENDING",
"FAILED",
}
}
type EcrScanFrequency string
// Enum values for EcrScanFrequency
const (
EcrScanFrequencyManual EcrScanFrequency = "MANUAL"
EcrScanFrequencyScanOnPush EcrScanFrequency = "SCAN_ON_PUSH"
EcrScanFrequencyContinuousScan EcrScanFrequency = "CONTINUOUS_SCAN"
)
// Values returns all known values for EcrScanFrequency. 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 (EcrScanFrequency) Values() []EcrScanFrequency {
return []EcrScanFrequency{
"MANUAL",
"SCAN_ON_PUSH",
"CONTINUOUS_SCAN",
}
}
type ErrorCode string
// Enum values for ErrorCode
const (
ErrorCodeAlreadyEnabled ErrorCode = "ALREADY_ENABLED"
ErrorCodeEnableInProgress ErrorCode = "ENABLE_IN_PROGRESS"
ErrorCodeDisableInProgress ErrorCode = "DISABLE_IN_PROGRESS"
ErrorCodeSuspendInProgress ErrorCode = "SUSPEND_IN_PROGRESS"
ErrorCodeResourceNotFound ErrorCode = "RESOURCE_NOT_FOUND"
ErrorCodeAccessDenied ErrorCode = "ACCESS_DENIED"
ErrorCodeInternalError ErrorCode = "INTERNAL_ERROR"
ErrorCodeSsmUnavailable ErrorCode = "SSM_UNAVAILABLE"
ErrorCodeSsmThrottled ErrorCode = "SSM_THROTTLED"
ErrorCodeEventbridgeUnavailable ErrorCode = "EVENTBRIDGE_UNAVAILABLE"
ErrorCodeEventbridgeThrottled ErrorCode = "EVENTBRIDGE_THROTTLED"
ErrorCodeResourceScanNotDisabled ErrorCode = "RESOURCE_SCAN_NOT_DISABLED"
ErrorCodeDisassociateAllMembers ErrorCode = "DISASSOCIATE_ALL_MEMBERS"
ErrorCodeAccountIsIsolated ErrorCode = "ACCOUNT_IS_ISOLATED"
)
// Values returns all known values for ErrorCode. 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 (ErrorCode) Values() []ErrorCode {
return []ErrorCode{
"ALREADY_ENABLED",
"ENABLE_IN_PROGRESS",
"DISABLE_IN_PROGRESS",
"SUSPEND_IN_PROGRESS",
"RESOURCE_NOT_FOUND",
"ACCESS_DENIED",
"INTERNAL_ERROR",
"SSM_UNAVAILABLE",
"SSM_THROTTLED",
"EVENTBRIDGE_UNAVAILABLE",
"EVENTBRIDGE_THROTTLED",
"RESOURCE_SCAN_NOT_DISABLED",
"DISASSOCIATE_ALL_MEMBERS",
"ACCOUNT_IS_ISOLATED",
}
}
type ExploitAvailable string
// Enum values for ExploitAvailable
const (
ExploitAvailableYes ExploitAvailable = "YES"
ExploitAvailableNo ExploitAvailable = "NO"
)
// Values returns all known values for ExploitAvailable. 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 (ExploitAvailable) Values() []ExploitAvailable {
return []ExploitAvailable{
"YES",
"NO",
}
}
type ExternalReportStatus string
// Enum values for ExternalReportStatus
const (
ExternalReportStatusSucceeded ExternalReportStatus = "SUCCEEDED"
ExternalReportStatusInProgress ExternalReportStatus = "IN_PROGRESS"
ExternalReportStatusCancelled ExternalReportStatus = "CANCELLED"
ExternalReportStatusFailed ExternalReportStatus = "FAILED"
)
// Values returns all known values for ExternalReportStatus. 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 (ExternalReportStatus) Values() []ExternalReportStatus {
return []ExternalReportStatus{
"SUCCEEDED",
"IN_PROGRESS",
"CANCELLED",
"FAILED",
}
}
type FilterAction string
// Enum values for FilterAction
const (
FilterActionNone FilterAction = "NONE"
FilterActionSuppress FilterAction = "SUPPRESS"
)
// Values returns all known values for FilterAction. 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 (FilterAction) Values() []FilterAction {
return []FilterAction{
"NONE",
"SUPPRESS",
}
}
type FindingStatus string
// Enum values for FindingStatus
const (
FindingStatusActive FindingStatus = "ACTIVE"
FindingStatusSuppressed FindingStatus = "SUPPRESSED"
FindingStatusClosed FindingStatus = "CLOSED"
)
// Values returns all known values for FindingStatus. 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 (FindingStatus) Values() []FindingStatus {
return []FindingStatus{
"ACTIVE",
"SUPPRESSED",
"CLOSED",
}
}
type FindingType string
// Enum values for FindingType
const (
FindingTypeNetworkReachability FindingType = "NETWORK_REACHABILITY"
FindingTypePackageVulnerability FindingType = "PACKAGE_VULNERABILITY"
FindingTypeCodeVulnerability FindingType = "CODE_VULNERABILITY"
)
// Values returns all known values for FindingType. 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 (FindingType) Values() []FindingType {
return []FindingType{
"NETWORK_REACHABILITY",
"PACKAGE_VULNERABILITY",
"CODE_VULNERABILITY",
}
}
type FindingTypeSortBy string
// Enum values for FindingTypeSortBy
const (
FindingTypeSortByCritical FindingTypeSortBy = "CRITICAL"
FindingTypeSortByHigh FindingTypeSortBy = "HIGH"
FindingTypeSortByAll FindingTypeSortBy = "ALL"
)
// Values returns all known values for FindingTypeSortBy. 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 (FindingTypeSortBy) Values() []FindingTypeSortBy {
return []FindingTypeSortBy{
"CRITICAL",
"HIGH",
"ALL",
}
}
type FixAvailable string
// Enum values for FixAvailable
const (
FixAvailableYes FixAvailable = "YES"
FixAvailableNo FixAvailable = "NO"
FixAvailablePartial FixAvailable = "PARTIAL"
)
// Values returns all known values for FixAvailable. 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 (FixAvailable) Values() []FixAvailable {
return []FixAvailable{
"YES",
"NO",
"PARTIAL",
}
}
type FreeTrialInfoErrorCode string
// Enum values for FreeTrialInfoErrorCode
const (
FreeTrialInfoErrorCodeAccessDenied FreeTrialInfoErrorCode = "ACCESS_DENIED"
FreeTrialInfoErrorCodeInternalError FreeTrialInfoErrorCode = "INTERNAL_ERROR"
)
// Values returns all known values for FreeTrialInfoErrorCode. 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 (FreeTrialInfoErrorCode) Values() []FreeTrialInfoErrorCode {
return []FreeTrialInfoErrorCode{
"ACCESS_DENIED",
"INTERNAL_ERROR",
}
}
type FreeTrialStatus string
// Enum values for FreeTrialStatus
const (
FreeTrialStatusActive FreeTrialStatus = "ACTIVE"
FreeTrialStatusInactive FreeTrialStatus = "INACTIVE"
)
// Values returns all known values for FreeTrialStatus. 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 (FreeTrialStatus) Values() []FreeTrialStatus {
return []FreeTrialStatus{
"ACTIVE",
"INACTIVE",
}
}
type FreeTrialType string
// Enum values for FreeTrialType
const (
FreeTrialTypeEc2 FreeTrialType = "EC2"
FreeTrialTypeEcr FreeTrialType = "ECR"
FreeTrialTypeLambda FreeTrialType = "LAMBDA"
FreeTrialTypeLambdaCode FreeTrialType = "LAMBDA_CODE"
)
// Values returns all known values for FreeTrialType. 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 (FreeTrialType) Values() []FreeTrialType {
return []FreeTrialType{
"EC2",
"ECR",
"LAMBDA",
"LAMBDA_CODE",
}
}
type GroupKey string
// Enum values for GroupKey
const (
GroupKeyScanStatusCode GroupKey = "SCAN_STATUS_CODE"
GroupKeyScanStatusReason GroupKey = "SCAN_STATUS_REASON"
GroupKeyAccountId GroupKey = "ACCOUNT_ID"
GroupKeyResourceType GroupKey = "RESOURCE_TYPE"
GroupKeyEcrRepositoryName GroupKey = "ECR_REPOSITORY_NAME"
)
// Values returns all known values for GroupKey. 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 (GroupKey) Values() []GroupKey {
return []GroupKey{
"SCAN_STATUS_CODE",
"SCAN_STATUS_REASON",
"ACCOUNT_ID",
"RESOURCE_TYPE",
"ECR_REPOSITORY_NAME",
}
}
type ImageLayerSortBy string
// Enum values for ImageLayerSortBy
const (
ImageLayerSortByCritical ImageLayerSortBy = "CRITICAL"
ImageLayerSortByHigh ImageLayerSortBy = "HIGH"
ImageLayerSortByAll ImageLayerSortBy = "ALL"
)
// Values returns all known values for ImageLayerSortBy. 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 (ImageLayerSortBy) Values() []ImageLayerSortBy {
return []ImageLayerSortBy{
"CRITICAL",
"HIGH",
"ALL",
}
}
type LambdaFunctionSortBy string
// Enum values for LambdaFunctionSortBy
const (
LambdaFunctionSortByCritical LambdaFunctionSortBy = "CRITICAL"
LambdaFunctionSortByHigh LambdaFunctionSortBy = "HIGH"
LambdaFunctionSortByAll LambdaFunctionSortBy = "ALL"
)
// Values returns all known values for LambdaFunctionSortBy. 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 (LambdaFunctionSortBy) Values() []LambdaFunctionSortBy {
return []LambdaFunctionSortBy{
"CRITICAL",
"HIGH",
"ALL",
}
}
type LambdaLayerSortBy string
// Enum values for LambdaLayerSortBy
const (
LambdaLayerSortByCritical LambdaLayerSortBy = "CRITICAL"
LambdaLayerSortByHigh LambdaLayerSortBy = "HIGH"
LambdaLayerSortByAll LambdaLayerSortBy = "ALL"
)
// Values returns all known values for LambdaLayerSortBy. 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 (LambdaLayerSortBy) Values() []LambdaLayerSortBy {
return []LambdaLayerSortBy{
"CRITICAL",
"HIGH",
"ALL",
}
}
type MapComparison string
// Enum values for MapComparison
const (
MapComparisonEquals MapComparison = "EQUALS"
)
// Values returns all known values for MapComparison. 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 (MapComparison) Values() []MapComparison {
return []MapComparison{
"EQUALS",
}
}
type NetworkProtocol string
// Enum values for NetworkProtocol
const (
NetworkProtocolTcp NetworkProtocol = "TCP"
NetworkProtocolUdp NetworkProtocol = "UDP"
)
// Values returns all known values for NetworkProtocol. 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 (NetworkProtocol) Values() []NetworkProtocol {
return []NetworkProtocol{
"TCP",
"UDP",
}
}
type Operation string
// Enum values for Operation
const (
OperationEnableScanning Operation = "ENABLE_SCANNING"
OperationDisableScanning Operation = "DISABLE_SCANNING"
OperationEnableRepository Operation = "ENABLE_REPOSITORY"
OperationDisableRepository Operation = "DISABLE_REPOSITORY"
)
// Values returns all known values for Operation. 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 (Operation) Values() []Operation {
return []Operation{
"ENABLE_SCANNING",
"DISABLE_SCANNING",
"ENABLE_REPOSITORY",
"DISABLE_REPOSITORY",
}
}
type PackageManager string
// Enum values for PackageManager
const (
PackageManagerBundler PackageManager = "BUNDLER"
PackageManagerCargo PackageManager = "CARGO"
PackageManagerComposer PackageManager = "COMPOSER"
PackageManagerNpm PackageManager = "NPM"
PackageManagerNuget PackageManager = "NUGET"
PackageManagerPipenv PackageManager = "PIPENV"
PackageManagerPoetry PackageManager = "POETRY"
PackageManagerYarn PackageManager = "YARN"
PackageManagerGobinary PackageManager = "GOBINARY"
PackageManagerGomod PackageManager = "GOMOD"
PackageManagerJar PackageManager = "JAR"
PackageManagerOs PackageManager = "OS"
PackageManagerPip PackageManager = "PIP"
PackageManagerPythonpkg PackageManager = "PYTHONPKG"
PackageManagerNodepkg PackageManager = "NODEPKG"
PackageManagerPom PackageManager = "POM"
PackageManagerGemspec PackageManager = "GEMSPEC"
)
// Values returns all known values for PackageManager. 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 (PackageManager) Values() []PackageManager {
return []PackageManager{
"BUNDLER",
"CARGO",
"COMPOSER",
"NPM",
"NUGET",
"PIPENV",
"POETRY",
"YARN",
"GOBINARY",
"GOMOD",
"JAR",
"OS",
"PIP",
"PYTHONPKG",
"NODEPKG",
"POM",
"GEMSPEC",
}
}
type PackageSortBy string
// Enum values for PackageSortBy
const (
PackageSortByCritical PackageSortBy = "CRITICAL"
PackageSortByHigh PackageSortBy = "HIGH"
PackageSortByAll PackageSortBy = "ALL"
)
// Values returns all known values for PackageSortBy. 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 (PackageSortBy) Values() []PackageSortBy {
return []PackageSortBy{
"CRITICAL",
"HIGH",
"ALL",
}
}
type PackageType string
// Enum values for PackageType
const (
PackageTypeImage PackageType = "IMAGE"
PackageTypeZip PackageType = "ZIP"
)
// Values returns all known values for PackageType. 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 (PackageType) Values() []PackageType {
return []PackageType{
"IMAGE",
"ZIP",
}
}
type RelationshipStatus string
// Enum values for RelationshipStatus
const (
RelationshipStatusCreated RelationshipStatus = "CREATED"
RelationshipStatusInvited RelationshipStatus = "INVITED"
RelationshipStatusDisabled RelationshipStatus = "DISABLED"
RelationshipStatusEnabled RelationshipStatus = "ENABLED"
RelationshipStatusRemoved RelationshipStatus = "REMOVED"
RelationshipStatusResigned RelationshipStatus = "RESIGNED"
RelationshipStatusDeleted RelationshipStatus = "DELETED"
RelationshipStatusEmailVerificationInProgress RelationshipStatus = "EMAIL_VERIFICATION_IN_PROGRESS"
RelationshipStatusEmailVerificationFailed RelationshipStatus = "EMAIL_VERIFICATION_FAILED"
RelationshipStatusRegionDisabled RelationshipStatus = "REGION_DISABLED"
RelationshipStatusAccountSuspended RelationshipStatus = "ACCOUNT_SUSPENDED"
RelationshipStatusCannotCreateDetectorInOrgMaster RelationshipStatus = "CANNOT_CREATE_DETECTOR_IN_ORG_MASTER"
)
// Values returns all known values for RelationshipStatus. 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 (RelationshipStatus) Values() []RelationshipStatus {
return []RelationshipStatus{
"CREATED",
"INVITED",
"DISABLED",
"ENABLED",
"REMOVED",
"RESIGNED",
"DELETED",
"EMAIL_VERIFICATION_IN_PROGRESS",
"EMAIL_VERIFICATION_FAILED",
"REGION_DISABLED",
"ACCOUNT_SUSPENDED",
"CANNOT_CREATE_DETECTOR_IN_ORG_MASTER",
}
}
type ReportFormat string
// Enum values for ReportFormat
const (
ReportFormatCsv ReportFormat = "CSV"
ReportFormatJson ReportFormat = "JSON"
)
// Values returns all known values for ReportFormat. 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 (ReportFormat) Values() []ReportFormat {
return []ReportFormat{
"CSV",
"JSON",
}
}
type ReportingErrorCode string
// Enum values for ReportingErrorCode
const (
ReportingErrorCodeInternalError ReportingErrorCode = "INTERNAL_ERROR"
ReportingErrorCodeInvalidPermissions ReportingErrorCode = "INVALID_PERMISSIONS"
ReportingErrorCodeNoFindingsFound ReportingErrorCode = "NO_FINDINGS_FOUND"
ReportingErrorCodeBucketNotFound ReportingErrorCode = "BUCKET_NOT_FOUND"
ReportingErrorCodeIncompatibleBucketRegion ReportingErrorCode = "INCOMPATIBLE_BUCKET_REGION"
ReportingErrorCodeMalformedKmsKey ReportingErrorCode = "MALFORMED_KMS_KEY"
)
// Values returns all known values for ReportingErrorCode. 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 (ReportingErrorCode) Values() []ReportingErrorCode {
return []ReportingErrorCode{
"INTERNAL_ERROR",
"INVALID_PERMISSIONS",
"NO_FINDINGS_FOUND",
"BUCKET_NOT_FOUND",
"INCOMPATIBLE_BUCKET_REGION",
"MALFORMED_KMS_KEY",
}
}
type RepositorySortBy string
// Enum values for RepositorySortBy
const (
RepositorySortByCritical RepositorySortBy = "CRITICAL"
RepositorySortByHigh RepositorySortBy = "HIGH"
RepositorySortByAll RepositorySortBy = "ALL"
RepositorySortByAffectedImages RepositorySortBy = "AFFECTED_IMAGES"
)
// Values returns all known values for RepositorySortBy. 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 (RepositorySortBy) Values() []RepositorySortBy {
return []RepositorySortBy{
"CRITICAL",
"HIGH",
"ALL",
"AFFECTED_IMAGES",
}
}
type ResourceMapComparison string
// Enum values for ResourceMapComparison
const (
ResourceMapComparisonEquals ResourceMapComparison = "EQUALS"
)
// Values returns all known values for ResourceMapComparison. 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 (ResourceMapComparison) Values() []ResourceMapComparison {
return []ResourceMapComparison{
"EQUALS",
}
}
type ResourceScanType string
// Enum values for ResourceScanType
const (
ResourceScanTypeEc2 ResourceScanType = "EC2"
ResourceScanTypeEcr ResourceScanType = "ECR"
ResourceScanTypeLambda ResourceScanType = "LAMBDA"
ResourceScanTypeLambdaCode ResourceScanType = "LAMBDA_CODE"
)
// Values returns all known values for ResourceScanType. 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 (ResourceScanType) Values() []ResourceScanType {
return []ResourceScanType{
"EC2",
"ECR",
"LAMBDA",
"LAMBDA_CODE",
}
}
type ResourceStringComparison string
// Enum values for ResourceStringComparison
const (
ResourceStringComparisonEquals ResourceStringComparison = "EQUALS"
ResourceStringComparisonNotEquals ResourceStringComparison = "NOT_EQUALS"
)
// Values returns all known values for ResourceStringComparison. 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 (ResourceStringComparison) Values() []ResourceStringComparison {
return []ResourceStringComparison{
"EQUALS",
"NOT_EQUALS",
}
}
type ResourceType string
// Enum values for ResourceType
const (
ResourceTypeAwsEc2Instance ResourceType = "AWS_EC2_INSTANCE"
ResourceTypeAwsEcrContainerImage ResourceType = "AWS_ECR_CONTAINER_IMAGE"
ResourceTypeAwsEcrRepository ResourceType = "AWS_ECR_REPOSITORY"
ResourceTypeAwsLambdaFunction ResourceType = "AWS_LAMBDA_FUNCTION"
)
// Values returns all known values for ResourceType. 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 (ResourceType) Values() []ResourceType {
return []ResourceType{
"AWS_EC2_INSTANCE",
"AWS_ECR_CONTAINER_IMAGE",
"AWS_ECR_REPOSITORY",
"AWS_LAMBDA_FUNCTION",
}
}
type Runtime string
// Enum values for Runtime
const (
RuntimeNodejs Runtime = "NODEJS"
RuntimeNodejs12X Runtime = "NODEJS_12_X"
RuntimeNodejs14X Runtime = "NODEJS_14_X"
RuntimeNodejs16X Runtime = "NODEJS_16_X"
RuntimeJava8 Runtime = "JAVA_8"
RuntimeJava8Al2 Runtime = "JAVA_8_AL2"
RuntimeJava11 Runtime = "JAVA_11"
RuntimePython37 Runtime = "PYTHON_3_7"
RuntimePython38 Runtime = "PYTHON_3_8"
RuntimePython39 Runtime = "PYTHON_3_9"
RuntimeUnsupported Runtime = "UNSUPPORTED"
RuntimeNodejs18X Runtime = "NODEJS_18_X"
RuntimeGo1X Runtime = "GO_1_X"
RuntimeJava17 Runtime = "JAVA_17"
RuntimePython310 Runtime = "PYTHON_3_10"
)
// Values returns all known values for Runtime. 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 (Runtime) Values() []Runtime {
return []Runtime{
"NODEJS",
"NODEJS_12_X",
"NODEJS_14_X",
"NODEJS_16_X",
"JAVA_8",
"JAVA_8_AL2",
"JAVA_11",
"PYTHON_3_7",
"PYTHON_3_8",
"PYTHON_3_9",
"UNSUPPORTED",
"NODEJS_18_X",
"GO_1_X",
"JAVA_17",
"PYTHON_3_10",
}
}
type SbomReportFormat string
// Enum values for SbomReportFormat
const (
SbomReportFormatCyclonedx14 SbomReportFormat = "CYCLONEDX_1_4"
SbomReportFormatSpdx23 SbomReportFormat = "SPDX_2_3"
)
// Values returns all known values for SbomReportFormat. 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 (SbomReportFormat) Values() []SbomReportFormat {
return []SbomReportFormat{
"CYCLONEDX_1_4",
"SPDX_2_3",
}
}
type ScanStatusCode string
// Enum values for ScanStatusCode
const (
ScanStatusCodeActive ScanStatusCode = "ACTIVE"
ScanStatusCodeInactive ScanStatusCode = "INACTIVE"
)
// Values returns all known values for ScanStatusCode. 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 (ScanStatusCode) Values() []ScanStatusCode {
return []ScanStatusCode{
"ACTIVE",
"INACTIVE",
}
}
type ScanStatusReason string
// Enum values for ScanStatusReason
const (
ScanStatusReasonPendingInitialScan ScanStatusReason = "PENDING_INITIAL_SCAN"
ScanStatusReasonAccessDenied ScanStatusReason = "ACCESS_DENIED"
ScanStatusReasonInternalError ScanStatusReason = "INTERNAL_ERROR"
ScanStatusReasonUnmanagedEc2Instance ScanStatusReason = "UNMANAGED_EC2_INSTANCE"
ScanStatusReasonUnsupportedOs ScanStatusReason = "UNSUPPORTED_OS"
ScanStatusReasonScanEligibilityExpired ScanStatusReason = "SCAN_ELIGIBILITY_EXPIRED"
ScanStatusReasonResourceTerminated ScanStatusReason = "RESOURCE_TERMINATED"
ScanStatusReasonSuccessful ScanStatusReason = "SUCCESSFUL"
ScanStatusReasonNoResourcesFound ScanStatusReason = "NO_RESOURCES_FOUND"
ScanStatusReasonImageSizeExceeded ScanStatusReason = "IMAGE_SIZE_EXCEEDED"
ScanStatusReasonScanFrequencyManual ScanStatusReason = "SCAN_FREQUENCY_MANUAL"
ScanStatusReasonScanFrequencyScanOnPush ScanStatusReason = "SCAN_FREQUENCY_SCAN_ON_PUSH"
ScanStatusReasonEc2InstanceStopped ScanStatusReason = "EC2_INSTANCE_STOPPED"
ScanStatusReasonPendingDisable ScanStatusReason = "PENDING_DISABLE"
ScanStatusReasonNoInventory ScanStatusReason = "NO_INVENTORY"
ScanStatusReasonStaleInventory ScanStatusReason = "STALE_INVENTORY"
ScanStatusReasonExcludedByTag ScanStatusReason = "EXCLUDED_BY_TAG"
ScanStatusReasonUnsupportedRuntime ScanStatusReason = "UNSUPPORTED_RUNTIME"
ScanStatusReasonUnsupportedMediaType ScanStatusReason = "UNSUPPORTED_MEDIA_TYPE"
ScanStatusReasonUnsupportedConfigFile ScanStatusReason = "UNSUPPORTED_CONFIG_FILE"
ScanStatusReasonDeepInspectionPackageCollectionLimitExceeded ScanStatusReason = "DEEP_INSPECTION_PACKAGE_COLLECTION_LIMIT_EXCEEDED"
ScanStatusReasonDeepInspectionDailySsmInventoryLimitExceeded ScanStatusReason = "DEEP_INSPECTION_DAILY_SSM_INVENTORY_LIMIT_EXCEEDED"
ScanStatusReasonDeepInspectionCollectionTimeLimitExceeded ScanStatusReason = "DEEP_INSPECTION_COLLECTION_TIME_LIMIT_EXCEEDED"
ScanStatusReasonDeepInspectionNoInventory ScanStatusReason = "DEEP_INSPECTION_NO_INVENTORY"
)
// Values returns all known values for ScanStatusReason. 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 (ScanStatusReason) Values() []ScanStatusReason {
return []ScanStatusReason{
"PENDING_INITIAL_SCAN",
"ACCESS_DENIED",
"INTERNAL_ERROR",
"UNMANAGED_EC2_INSTANCE",
"UNSUPPORTED_OS",
"SCAN_ELIGIBILITY_EXPIRED",
"RESOURCE_TERMINATED",
"SUCCESSFUL",
"NO_RESOURCES_FOUND",
"IMAGE_SIZE_EXCEEDED",
"SCAN_FREQUENCY_MANUAL",
"SCAN_FREQUENCY_SCAN_ON_PUSH",
"EC2_INSTANCE_STOPPED",
"PENDING_DISABLE",
"NO_INVENTORY",
"STALE_INVENTORY",
"EXCLUDED_BY_TAG",
"UNSUPPORTED_RUNTIME",
"UNSUPPORTED_MEDIA_TYPE",
"UNSUPPORTED_CONFIG_FILE",
"DEEP_INSPECTION_PACKAGE_COLLECTION_LIMIT_EXCEEDED",
"DEEP_INSPECTION_DAILY_SSM_INVENTORY_LIMIT_EXCEEDED",
"DEEP_INSPECTION_COLLECTION_TIME_LIMIT_EXCEEDED",
"DEEP_INSPECTION_NO_INVENTORY",
}
}
type ScanType string
// Enum values for ScanType
const (
ScanTypeNetwork ScanType = "NETWORK"
ScanTypePackage ScanType = "PACKAGE"
ScanTypeCode ScanType = "CODE"
)
// Values returns all known values for ScanType. 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 (ScanType) Values() []ScanType {
return []ScanType{
"NETWORK",
"PACKAGE",
"CODE",
}
}
type Service string
// Enum values for Service
const (
ServiceEc2 Service = "EC2"
ServiceEcr Service = "ECR"
ServiceLambda Service = "LAMBDA"
)
// Values returns all known values for Service. 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 (Service) Values() []Service {
return []Service{
"EC2",
"ECR",
"LAMBDA",
}
}
type Severity string
// Enum values for Severity
const (
SeverityInformational Severity = "INFORMATIONAL"
SeverityLow Severity = "LOW"
SeverityMedium Severity = "MEDIUM"
SeverityHigh Severity = "HIGH"
SeverityCritical Severity = "CRITICAL"
SeverityUntriaged Severity = "UNTRIAGED"
)
// Values returns all known values for Severity. 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 (Severity) Values() []Severity {
return []Severity{
"INFORMATIONAL",
"LOW",
"MEDIUM",
"HIGH",
"CRITICAL",
"UNTRIAGED",
}
}
type SortField string
// Enum values for SortField
const (
SortFieldAwsAccountId SortField = "AWS_ACCOUNT_ID"
SortFieldFindingType SortField = "FINDING_TYPE"
SortFieldSeverity SortField = "SEVERITY"
SortFieldFirstObservedAt SortField = "FIRST_OBSERVED_AT"
SortFieldLastObservedAt SortField = "LAST_OBSERVED_AT"
SortFieldFindingStatus SortField = "FINDING_STATUS"
SortFieldResourceType SortField = "RESOURCE_TYPE"
SortFieldEcrImagePushedAt SortField = "ECR_IMAGE_PUSHED_AT"
SortFieldEcrImageRepositoryName SortField = "ECR_IMAGE_REPOSITORY_NAME"
SortFieldEcrImageRegistry SortField = "ECR_IMAGE_REGISTRY"
SortFieldNetworkProtocol SortField = "NETWORK_PROTOCOL"
SortFieldComponentType SortField = "COMPONENT_TYPE"
SortFieldVulnerabilityId SortField = "VULNERABILITY_ID"
SortFieldVulnerabilitySource SortField = "VULNERABILITY_SOURCE"
SortFieldInspectorScore SortField = "INSPECTOR_SCORE"
SortFieldVendorSeverity SortField = "VENDOR_SEVERITY"
SortFieldEpssScore SortField = "EPSS_SCORE"
)
// Values returns all known values for SortField. 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 (SortField) Values() []SortField {
return []SortField{
"AWS_ACCOUNT_ID",
"FINDING_TYPE",
"SEVERITY",
"FIRST_OBSERVED_AT",
"LAST_OBSERVED_AT",
"FINDING_STATUS",
"RESOURCE_TYPE",
"ECR_IMAGE_PUSHED_AT",
"ECR_IMAGE_REPOSITORY_NAME",
"ECR_IMAGE_REGISTRY",
"NETWORK_PROTOCOL",
"COMPONENT_TYPE",
"VULNERABILITY_ID",
"VULNERABILITY_SOURCE",
"INSPECTOR_SCORE",
"VENDOR_SEVERITY",
"EPSS_SCORE",
}
}
type SortOrder string
// Enum values for SortOrder
const (
SortOrderAsc SortOrder = "ASC"
SortOrderDesc SortOrder = "DESC"
)
// Values returns all known values for SortOrder. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (SortOrder) Values() []SortOrder {
return []SortOrder{
"ASC",
"DESC",
}
}
type Status string
// Enum values for Status
const (
StatusEnabling Status = "ENABLING"
StatusEnabled Status = "ENABLED"
StatusDisabling Status = "DISABLING"
StatusDisabled Status = "DISABLED"
StatusSuspending Status = "SUSPENDING"
StatusSuspended Status = "SUSPENDED"
)
// Values returns all known values for Status. Note that this can be expanded in
// the future, and so it is only as up to date as the client. The ordering of this
// slice is not guaranteed to be stable across updates.
func (Status) Values() []Status {
return []Status{
"ENABLING",
"ENABLED",
"DISABLING",
"DISABLED",
"SUSPENDING",
"SUSPENDED",
}
}
type StringComparison string
// Enum values for StringComparison
const (
StringComparisonEquals StringComparison = "EQUALS"
StringComparisonPrefix StringComparison = "PREFIX"
StringComparisonNotEquals StringComparison = "NOT_EQUALS"
)
// Values returns all known values for StringComparison. 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 (StringComparison) Values() []StringComparison {
return []StringComparison{
"EQUALS",
"PREFIX",
"NOT_EQUALS",
}
}
type TitleSortBy string
// Enum values for TitleSortBy
const (
TitleSortByCritical TitleSortBy = "CRITICAL"
TitleSortByHigh TitleSortBy = "HIGH"
TitleSortByAll TitleSortBy = "ALL"
)
// Values returns all known values for TitleSortBy. 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 (TitleSortBy) Values() []TitleSortBy {
return []TitleSortBy{
"CRITICAL",
"HIGH",
"ALL",
}
}
type UsageType string
// Enum values for UsageType
const (
UsageTypeEc2InstanceHours UsageType = "EC2_INSTANCE_HOURS"
UsageTypeEcrInitialScan UsageType = "ECR_INITIAL_SCAN"
UsageTypeEcrRescan UsageType = "ECR_RESCAN"
UsageTypeLambdaFunctionHours UsageType = "LAMBDA_FUNCTION_HOURS"
UsageTypeLambdaFunctionCodeHours UsageType = "LAMBDA_FUNCTION_CODE_HOURS"
)
// Values returns all known values for UsageType. 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 (UsageType) Values() []UsageType {
return []UsageType{
"EC2_INSTANCE_HOURS",
"ECR_INITIAL_SCAN",
"ECR_RESCAN",
"LAMBDA_FUNCTION_HOURS",
"LAMBDA_FUNCTION_CODE_HOURS",
}
}
type ValidationExceptionReason string
// Enum values for ValidationExceptionReason
const (
ValidationExceptionReasonCannotParse ValidationExceptionReason = "CANNOT_PARSE"
ValidationExceptionReasonFieldValidationFailed ValidationExceptionReason = "FIELD_VALIDATION_FAILED"
ValidationExceptionReasonOther ValidationExceptionReason = "OTHER"
)
// Values returns all known values for ValidationExceptionReason. 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 (ValidationExceptionReason) Values() []ValidationExceptionReason {
return []ValidationExceptionReason{
"CANNOT_PARSE",
"FIELD_VALIDATION_FAILED",
"OTHER",
}
}
type VulnerabilitySource string
// Enum values for VulnerabilitySource
const (
VulnerabilitySourceNvd VulnerabilitySource = "NVD"
)
// Values returns all known values for VulnerabilitySource. 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 (VulnerabilitySource) Values() []VulnerabilitySource {
return []VulnerabilitySource{
"NVD",
}
}
| 1,442 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
"fmt"
smithy "github.com/aws/smithy-go"
)
// You do not have sufficient access to perform this action.
type AccessDeniedException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *AccessDeniedException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *AccessDeniedException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *AccessDeniedException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "AccessDeniedException"
}
return *e.ErrorCodeOverride
}
func (e *AccessDeniedException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// One or more tags submitted as part of the request is not valid.
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 }
// A conflict occurred.
type ConflictException struct {
Message *string
ErrorCodeOverride *string
ResourceId *string
ResourceType *string
noSmithyDocumentSerde
}
func (e *ConflictException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ConflictException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ConflictException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ConflictException"
}
return *e.ErrorCodeOverride
}
func (e *ConflictException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The request has failed due to an internal failure of the Amazon Inspector
// service.
type InternalServerException struct {
Message *string
ErrorCodeOverride *string
RetryAfterSeconds *int32
noSmithyDocumentSerde
}
func (e *InternalServerException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InternalServerException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InternalServerException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InternalServerException"
}
return *e.ErrorCodeOverride
}
func (e *InternalServerException) ErrorFault() smithy.ErrorFault { return smithy.FaultServer }
// The operation tried to access an invalid resource. Make sure the resource is
// specified correctly.
type ResourceNotFoundException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ResourceNotFoundException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ResourceNotFoundException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ResourceNotFoundException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ResourceNotFoundException"
}
return *e.ErrorCodeOverride
}
func (e *ResourceNotFoundException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// You have exceeded your service quota. To perform the requested action, remove
// some of the relevant resources, or use Service Quotas to request a service quota
// increase.
type ServiceQuotaExceededException struct {
Message *string
ErrorCodeOverride *string
ResourceId *string
noSmithyDocumentSerde
}
func (e *ServiceQuotaExceededException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ServiceQuotaExceededException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ServiceQuotaExceededException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ServiceQuotaExceededException"
}
return *e.ErrorCodeOverride
}
func (e *ServiceQuotaExceededException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The limit on the number of requests per second was exceeded.
type ThrottlingException struct {
Message *string
ErrorCodeOverride *string
RetryAfterSeconds *int32
noSmithyDocumentSerde
}
func (e *ThrottlingException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ThrottlingException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ThrottlingException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ThrottlingException"
}
return *e.ErrorCodeOverride
}
func (e *ThrottlingException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The request has failed validation due to missing required fields or having
// invalid inputs.
type ValidationException struct {
Message *string
ErrorCodeOverride *string
Reason ValidationExceptionReason
Fields []ValidationExceptionField
noSmithyDocumentSerde
}
func (e *ValidationException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ValidationException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ValidationException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ValidationException"
}
return *e.ErrorCodeOverride
}
func (e *ValidationException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
| 234 |
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 Amazon Web Services account within your environment that Amazon Inspector
// has been enabled for.
type Account struct {
// The ID of the Amazon Web Services account.
//
// This member is required.
AccountId *string
// Details of the status of Amazon Inspector scans by resource type.
//
// This member is required.
ResourceStatus *ResourceStatus
// The status of Amazon Inspector for the account.
//
// This member is required.
Status Status
noSmithyDocumentSerde
}
// An object that contains details about an aggregation response based on Amazon
// Web Services accounts.
type AccountAggregation struct {
// The type of finding.
FindingType AggregationFindingType
// The type of resource.
ResourceType AggregationResourceType
// The value to sort by.
SortBy AccountSortBy
// The sort order (ascending or descending).
SortOrder SortOrder
noSmithyDocumentSerde
}
// An aggregation of findings by Amazon Web Services account ID.
type AccountAggregationResponse struct {
// The Amazon Web Services account ID.
AccountId *string
// The number of findings by severity.
SeverityCounts *SeverityCounts
noSmithyDocumentSerde
}
// An object with details the status of an Amazon Web Services account within your
// Amazon Inspector environment.
type AccountState struct {
// The Amazon Web Services account ID.
//
// This member is required.
AccountId *string
// An object detailing which resources Amazon Inspector is enabled to scan for the
// account.
//
// This member is required.
ResourceState *ResourceState
// An object detailing the status of Amazon Inspector for the account.
//
// This member is required.
State *State
noSmithyDocumentSerde
}
// Contains details about an aggregation request.
//
// The following types satisfy this interface:
//
// AggregationRequestMemberAccountAggregation
// AggregationRequestMemberAmiAggregation
// AggregationRequestMemberAwsEcrContainerAggregation
// AggregationRequestMemberEc2InstanceAggregation
// AggregationRequestMemberFindingTypeAggregation
// AggregationRequestMemberImageLayerAggregation
// AggregationRequestMemberLambdaFunctionAggregation
// AggregationRequestMemberLambdaLayerAggregation
// AggregationRequestMemberPackageAggregation
// AggregationRequestMemberRepositoryAggregation
// AggregationRequestMemberTitleAggregation
type AggregationRequest interface {
isAggregationRequest()
}
// An object that contains details about an aggregation request based on Amazon
// Web Services account IDs.
type AggregationRequestMemberAccountAggregation struct {
Value AccountAggregation
noSmithyDocumentSerde
}
func (*AggregationRequestMemberAccountAggregation) isAggregationRequest() {}
// An object that contains details about an aggregation request based on Amazon
// Machine Images (AMIs).
type AggregationRequestMemberAmiAggregation struct {
Value AmiAggregation
noSmithyDocumentSerde
}
func (*AggregationRequestMemberAmiAggregation) isAggregationRequest() {}
// An object that contains details about an aggregation request based on Amazon
// ECR container images.
type AggregationRequestMemberAwsEcrContainerAggregation struct {
Value AwsEcrContainerAggregation
noSmithyDocumentSerde
}
func (*AggregationRequestMemberAwsEcrContainerAggregation) isAggregationRequest() {}
// An object that contains details about an aggregation request based on Amazon
// EC2 instances.
type AggregationRequestMemberEc2InstanceAggregation struct {
Value Ec2InstanceAggregation
noSmithyDocumentSerde
}
func (*AggregationRequestMemberEc2InstanceAggregation) isAggregationRequest() {}
// An object that contains details about an aggregation request based on finding
// types.
type AggregationRequestMemberFindingTypeAggregation struct {
Value FindingTypeAggregation
noSmithyDocumentSerde
}
func (*AggregationRequestMemberFindingTypeAggregation) isAggregationRequest() {}
// An object that contains details about an aggregation request based on container
// image layers.
type AggregationRequestMemberImageLayerAggregation struct {
Value ImageLayerAggregation
noSmithyDocumentSerde
}
func (*AggregationRequestMemberImageLayerAggregation) isAggregationRequest() {}
// Returns an object with findings aggregated by AWS Lambda function.
type AggregationRequestMemberLambdaFunctionAggregation struct {
Value LambdaFunctionAggregation
noSmithyDocumentSerde
}
func (*AggregationRequestMemberLambdaFunctionAggregation) isAggregationRequest() {}
// Returns an object with findings aggregated by AWS Lambda layer.
type AggregationRequestMemberLambdaLayerAggregation struct {
Value LambdaLayerAggregation
noSmithyDocumentSerde
}
func (*AggregationRequestMemberLambdaLayerAggregation) isAggregationRequest() {}
// An object that contains details about an aggregation request based on operating
// system package type.
type AggregationRequestMemberPackageAggregation struct {
Value PackageAggregation
noSmithyDocumentSerde
}
func (*AggregationRequestMemberPackageAggregation) isAggregationRequest() {}
// An object that contains details about an aggregation request based on Amazon
// ECR repositories.
type AggregationRequestMemberRepositoryAggregation struct {
Value RepositoryAggregation
noSmithyDocumentSerde
}
func (*AggregationRequestMemberRepositoryAggregation) isAggregationRequest() {}
// An object that contains details about an aggregation request based on finding
// title.
type AggregationRequestMemberTitleAggregation struct {
Value TitleAggregation
noSmithyDocumentSerde
}
func (*AggregationRequestMemberTitleAggregation) isAggregationRequest() {}
// A structure that contains details about the results of an aggregation type.
//
// The following types satisfy this interface:
//
// AggregationResponseMemberAccountAggregation
// AggregationResponseMemberAmiAggregation
// AggregationResponseMemberAwsEcrContainerAggregation
// AggregationResponseMemberEc2InstanceAggregation
// AggregationResponseMemberFindingTypeAggregation
// AggregationResponseMemberImageLayerAggregation
// AggregationResponseMemberLambdaFunctionAggregation
// AggregationResponseMemberLambdaLayerAggregation
// AggregationResponseMemberPackageAggregation
// AggregationResponseMemberRepositoryAggregation
// AggregationResponseMemberTitleAggregation
type AggregationResponse interface {
isAggregationResponse()
}
// An object that contains details about an aggregation response based on Amazon
// Web Services account IDs.
type AggregationResponseMemberAccountAggregation struct {
Value AccountAggregationResponse
noSmithyDocumentSerde
}
func (*AggregationResponseMemberAccountAggregation) isAggregationResponse() {}
// An object that contains details about an aggregation response based on Amazon
// Machine Images (AMIs).
type AggregationResponseMemberAmiAggregation struct {
Value AmiAggregationResponse
noSmithyDocumentSerde
}
func (*AggregationResponseMemberAmiAggregation) isAggregationResponse() {}
// An object that contains details about an aggregation response based on Amazon
// ECR container images.
type AggregationResponseMemberAwsEcrContainerAggregation struct {
Value AwsEcrContainerAggregationResponse
noSmithyDocumentSerde
}
func (*AggregationResponseMemberAwsEcrContainerAggregation) isAggregationResponse() {}
// An object that contains details about an aggregation response based on Amazon
// EC2 instances.
type AggregationResponseMemberEc2InstanceAggregation struct {
Value Ec2InstanceAggregationResponse
noSmithyDocumentSerde
}
func (*AggregationResponseMemberEc2InstanceAggregation) isAggregationResponse() {}
// An object that contains details about an aggregation response based on finding
// types.
type AggregationResponseMemberFindingTypeAggregation struct {
Value FindingTypeAggregationResponse
noSmithyDocumentSerde
}
func (*AggregationResponseMemberFindingTypeAggregation) isAggregationResponse() {}
// An object that contains details about an aggregation response based on
// container image layers.
type AggregationResponseMemberImageLayerAggregation struct {
Value ImageLayerAggregationResponse
noSmithyDocumentSerde
}
func (*AggregationResponseMemberImageLayerAggregation) isAggregationResponse() {}
// An aggregation of findings by AWS Lambda function.
type AggregationResponseMemberLambdaFunctionAggregation struct {
Value LambdaFunctionAggregationResponse
noSmithyDocumentSerde
}
func (*AggregationResponseMemberLambdaFunctionAggregation) isAggregationResponse() {}
// An aggregation of findings by AWS Lambda layer.
type AggregationResponseMemberLambdaLayerAggregation struct {
Value LambdaLayerAggregationResponse
noSmithyDocumentSerde
}
func (*AggregationResponseMemberLambdaLayerAggregation) isAggregationResponse() {}
// An object that contains details about an aggregation response based on
// operating system package type.
type AggregationResponseMemberPackageAggregation struct {
Value PackageAggregationResponse
noSmithyDocumentSerde
}
func (*AggregationResponseMemberPackageAggregation) isAggregationResponse() {}
// An object that contains details about an aggregation response based on Amazon
// ECR repositories.
type AggregationResponseMemberRepositoryAggregation struct {
Value RepositoryAggregationResponse
noSmithyDocumentSerde
}
func (*AggregationResponseMemberRepositoryAggregation) isAggregationResponse() {}
// An object that contains details about an aggregation response based on finding
// title.
type AggregationResponseMemberTitleAggregation struct {
Value TitleAggregationResponse
noSmithyDocumentSerde
}
func (*AggregationResponseMemberTitleAggregation) isAggregationResponse() {}
// The details that define an aggregation based on Amazon machine images (AMIs).
type AmiAggregation struct {
// The IDs of AMIs to aggregate findings for.
Amis []StringFilter
// The value to sort results by.
SortBy AmiSortBy
// The order to sort results by.
SortOrder SortOrder
noSmithyDocumentSerde
}
// A response that contains the results of a finding aggregation by AMI.
type AmiAggregationResponse struct {
// The ID of the AMI that findings were aggregated for.
//
// This member is required.
Ami *string
// The Amazon Web Services account ID for the AMI.
AccountId *string
// The IDs of Amazon EC2 instances using this AMI.
AffectedInstances *int64
// An object that contains the count of matched findings per severity.
SeverityCounts *SeverityCounts
noSmithyDocumentSerde
}
// The Amazon Web Services Threat Intel Group (ATIG) details for a specific
// vulnerability.
type AtigData struct {
// The date and time this vulnerability was first observed.
FirstSeen *time.Time
// The date and time this vulnerability was last observed.
LastSeen *time.Time
// The commercial sectors this vulnerability targets.
Targets []string
// The MITRE ATT&CK (https://attack.mitre.org/) tactics, techniques, and
// procedures (TTPs) associated with vulnerability.
Ttps []string
noSmithyDocumentSerde
}
// Represents which scan types are automatically enabled for new members of your
// Amazon Inspector organization.
type AutoEnable struct {
// Represents whether Amazon EC2 scans are automatically enabled for new members
// of your Amazon Inspector organization.
//
// This member is required.
Ec2 *bool
// Represents whether Amazon ECR scans are automatically enabled for new members
// of your Amazon Inspector organization.
//
// This member is required.
Ecr *bool
// Represents whether AWS Lambda standard scans are automatically enabled for new
// members of your Amazon Inspector organization.
Lambda *bool
// Represents whether AWS Lambda code scans are automatically enabled for new
// members of your Amazon Inspector organization.
LambdaCode *bool
noSmithyDocumentSerde
}
// Details of the Amazon EC2 instance involved in a finding.
type AwsEc2InstanceDetails struct {
// The IAM instance profile ARN of the Amazon EC2 instance.
IamInstanceProfileArn *string
// The image ID of the Amazon EC2 instance.
ImageId *string
// The IPv4 addresses of the Amazon EC2 instance.
IpV4Addresses []string
// The IPv6 addresses of the Amazon EC2 instance.
IpV6Addresses []string
// The name of the key pair used to launch the Amazon EC2 instance.
KeyName *string
// The date and time the Amazon EC2 instance was launched at.
LaunchedAt *time.Time
// The platform of the Amazon EC2 instance.
Platform *string
// The subnet ID of the Amazon EC2 instance.
SubnetId *string
// The type of the Amazon EC2 instance.
Type *string
// The VPC ID of the Amazon EC2 instance.
VpcId *string
noSmithyDocumentSerde
}
// An aggregation of information about Amazon ECR containers.
type AwsEcrContainerAggregation struct {
// The architecture of the containers.
Architectures []StringFilter
// The image SHA values.
ImageShas []StringFilter
// The image tags.
ImageTags []StringFilter
// The container repositories.
Repositories []StringFilter
// The container resource IDs.
ResourceIds []StringFilter
// The value to sort by.
SortBy AwsEcrContainerSortBy
// The sort order (ascending or descending).
SortOrder SortOrder
noSmithyDocumentSerde
}
// An aggregation of information about Amazon ECR containers.
type AwsEcrContainerAggregationResponse struct {
// The resource ID of the container.
//
// This member is required.
ResourceId *string
// The Amazon Web Services account ID of the account that owns the container.
AccountId *string
// The architecture of the container.
Architecture *string
// The SHA value of the container image.
ImageSha *string
// The container image stags.
ImageTags []string
// The container repository.
Repository *string
// The number of finding by severity.
SeverityCounts *SeverityCounts
noSmithyDocumentSerde
}
// The image details of the Amazon ECR container image.
type AwsEcrContainerImageDetails struct {
// The image hash of the Amazon ECR container image.
//
// This member is required.
ImageHash *string
// The registry for the Amazon ECR container image.
//
// This member is required.
Registry *string
// The name of the repository the Amazon ECR container image resides in.
//
// This member is required.
RepositoryName *string
// The architecture of the Amazon ECR container image.
Architecture *string
// The image author of the Amazon ECR container image.
Author *string
// The image tags attached to the Amazon ECR container image.
ImageTags []string
// The platform of the Amazon ECR container image.
Platform *string
// The date and time the Amazon ECR container image was pushed.
PushedAt *time.Time
noSmithyDocumentSerde
}
// A summary of information about the AWS Lambda function.
type AwsLambdaFunctionDetails struct {
// The SHA256 hash of the AWS Lambda function's deployment package.
//
// This member is required.
CodeSha256 *string
// The AWS Lambda function's execution role.
//
// This member is required.
ExecutionRoleArn *string
// The name of the AWS Lambda function.
//
// This member is required.
FunctionName *string
// The runtime environment for the AWS Lambda function.
//
// This member is required.
Runtime Runtime
// The version of the AWS Lambda function.
//
// This member is required.
Version *string
// The instruction set architecture that the AWS Lambda function supports.
// Architecture is a string array with one of the valid values. The default
// architecture value is x86_64 .
Architectures []Architecture
// The date and time that a user last updated the configuration, in ISO 8601 format (https://www.iso.org/iso-8601-date-and-time-format.html)
LastModifiedAt *time.Time
// The AWS Lambda function's layers (https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html)
// . A Lambda function can have up to five layers.
Layers []string
// The type of deployment package. Set to Image for container image and set Zip
// for .zip file archive.
PackageType PackageType
// The AWS Lambda function's networking configuration.
VpcConfig *LambdaVpcConfig
noSmithyDocumentSerde
}
// The Cybersecurity and Infrastructure Security Agency (CISA) details for a
// specific vulnerability.
type CisaData struct {
// The remediation action recommended by CISA for this vulnerability.
Action *string
// The date and time CISA added this vulnerability to their catalogue.
DateAdded *time.Time
// The date and time CISA expects a fix to have been provided vulnerability.
DateDue *time.Time
noSmithyDocumentSerde
}
// Contains information on where a code vulnerability is located in your Lambda
// function.
type CodeFilePath struct {
// The line number of the last line of code that a vulnerability was found in.
//
// This member is required.
EndLine *int32
// The name of the file the code vulnerability was found in.
//
// This member is required.
FileName *string
// The file path to the code that a vulnerability was found in.
//
// This member is required.
FilePath *string
// The line number of the first line of code that a vulnerability was found in.
//
// This member is required.
StartLine *int32
noSmithyDocumentSerde
}
// Contains information on the lines of code associated with a code snippet.
type CodeLine struct {
// The content of a line of code
//
// This member is required.
Content *string
// The line number that a section of code is located at.
//
// This member is required.
LineNumber *int32
noSmithyDocumentSerde
}
// Contains information about any errors encountered while trying to retrieve a
// code snippet.
type CodeSnippetError struct {
// The error code for the error that prevented a code snippet from being retrieved.
//
// This member is required.
ErrorCode CodeSnippetErrorCode
// The error message received when Amazon Inspector failed to retrieve a code
// snippet.
//
// This member is required.
ErrorMessage *string
// The ARN of the finding that a code snippet couldn't be retrieved for.
//
// This member is required.
FindingArn *string
noSmithyDocumentSerde
}
// Contains information on a code snippet retrieved by Amazon Inspector from a
// code vulnerability finding.
type CodeSnippetResult struct {
// Contains information on the retrieved code snippet.
CodeSnippet []CodeLine
// The line number of the last line of a code snippet.
EndLine *int32
// The ARN of a finding that the code snippet is associated with.
FindingArn *string
// The line number of the first line of a code snippet.
StartLine *int32
// Details of a suggested code fix.
SuggestedFixes []SuggestedFix
noSmithyDocumentSerde
}
// Contains information on the code vulnerability identified in your Lambda
// function.
type CodeVulnerabilityDetails struct {
// The Common Weakness Enumeration (CWE) item associated with the detected
// vulnerability.
//
// This member is required.
Cwes []string
// The ID for the Amazon CodeGuru detector associated with the finding. For more
// information on detectors see Amazon CodeGuru Detector Library (https://docs.aws.amazon.com/codeguru/detector-library)
// .
//
// This member is required.
DetectorId *string
// The name of the detector used to identify the code vulnerability. For more
// information on detectors see CodeGuru Detector Library (https://docs.aws.amazon.com/codeguru/detector-library)
// .
//
// This member is required.
DetectorName *string
// Contains information on where the code vulnerability is located in your code.
//
// This member is required.
FilePath *CodeFilePath
// The detector tag associated with the vulnerability. Detector tags group related
// vulnerabilities by common themes or tactics. For a list of available tags by
// programming language, see Java tags (https://docs.aws.amazon.com/codeguru/detector-library/java/tags/)
// , or Python tags (https://docs.aws.amazon.com/codeguru/detector-library/python/tags/)
// .
DetectorTags []string
// A URL containing supporting documentation about the code vulnerability detected.
ReferenceUrls []string
// The identifier for a rule that was used to detect the code vulnerability.
RuleId *string
// The Amazon Resource Name (ARN) of the Lambda layer that the code vulnerability
// was detected in.
SourceLambdaLayerArn *string
noSmithyDocumentSerde
}
// a structure that contains information on the count of resources within a group.
type Counts struct {
// The number of resources.
Count int64
// The key associated with this group
GroupKey GroupKey
noSmithyDocumentSerde
}
// Contains details of a coverage date filter.
type CoverageDateFilter struct {
// A timestamp representing the end of the time period to filter results by.
EndInclusive *time.Time
// A timestamp representing the start of the time period to filter results by.
StartInclusive *time.Time
noSmithyDocumentSerde
}
// A structure that identifies filter criteria for GetCoverageStatistics .
type CoverageFilterCriteria struct {
// An array of Amazon Web Services account IDs to return coverage statistics for.
AccountId []CoverageStringFilter
// The Amazon EC2 instance tags to filter on.
Ec2InstanceTags []CoverageMapFilter
// The Amazon ECR image tags to filter on.
EcrImageTags []CoverageStringFilter
// The Amazon ECR repository name to filter on.
EcrRepositoryName []CoverageStringFilter
// Returns coverage statistics for AWS Lambda functions filtered by function names.
LambdaFunctionName []CoverageStringFilter
// Returns coverage statistics for AWS Lambda functions filtered by runtime.
LambdaFunctionRuntime []CoverageStringFilter
// Returns coverage statistics for AWS Lambda functions filtered by tag.
LambdaFunctionTags []CoverageMapFilter
// Filters Amazon Web Services resources based on whether Amazon Inspector has
// checked them for vulnerabilities within the specified time range.
LastScannedAt []CoverageDateFilter
// An array of Amazon Web Services resource IDs to return coverage statistics for.
ResourceId []CoverageStringFilter
// An array of Amazon Web Services resource types to return coverage statistics
// for. The values can be AWS_EC2_INSTANCE , AWS_LAMBDA_FUNCTION or
// AWS_ECR_REPOSITORY .
ResourceType []CoverageStringFilter
// The scan status code to filter on.
ScanStatusCode []CoverageStringFilter
// The scan status reason to filter on.
ScanStatusReason []CoverageStringFilter
// An array of Amazon Inspector scan types to return coverage statistics for.
ScanType []CoverageStringFilter
noSmithyDocumentSerde
}
// Contains details of a coverage map filter.
type CoverageMapFilter struct {
// The operator to compare coverage on.
//
// This member is required.
Comparison CoverageMapComparison
// The tag key associated with the coverage map filter.
//
// This member is required.
Key *string
// The tag value associated with the coverage map filter.
Value *string
noSmithyDocumentSerde
}
// Contains details of a coverage string filter.
type CoverageStringFilter struct {
// The operator to compare strings on.
//
// This member is required.
Comparison CoverageStringComparison
// The value to compare strings on.
//
// This member is required.
Value *string
noSmithyDocumentSerde
}
// An object that contains details about a resource covered by Amazon Inspector.
type CoveredResource struct {
// The Amazon Web Services account ID of the covered resource.
//
// This member is required.
AccountId *string
// The ID of the covered resource.
//
// This member is required.
ResourceId *string
// The type of the covered resource.
//
// This member is required.
ResourceType CoverageResourceType
// The Amazon Inspector scan type covering the resource.
//
// This member is required.
ScanType ScanType
// The date and time the resource was last checked for vulnerabilities.
LastScannedAt *time.Time
// An object that contains details about the metadata.
ResourceMetadata *ResourceScanMetadata
// The status of the scan covering the resource.
ScanStatus *ScanStatus
noSmithyDocumentSerde
}
// The Common Vulnerability Scoring System (CVSS) version 2 details for the
// vulnerability.
type Cvss2 struct {
// The CVSS v2 base score for the vulnerability.
BaseScore float64
// The scoring vector associated with the CVSS v2 score.
ScoringVector *string
noSmithyDocumentSerde
}
// The Common Vulnerability Scoring System (CVSS) version 3 details for the
// vulnerability.
type Cvss3 struct {
// The CVSS v3 base score for the vulnerability.
BaseScore float64
// The scoring vector associated with the CVSS v3 score.
ScoringVector *string
noSmithyDocumentSerde
}
// The CVSS score for a finding.
type CvssScore struct {
// The base CVSS score used for the finding.
//
// This member is required.
BaseScore *float64
// The vector string of the CVSS score.
//
// This member is required.
ScoringVector *string
// The source of the CVSS score.
//
// This member is required.
Source *string
// The version of CVSS used for the score.
//
// This member is required.
Version *string
noSmithyDocumentSerde
}
// Details on adjustments Amazon Inspector made to the CVSS score for a finding.
type CvssScoreAdjustment struct {
// The metric used to adjust the CVSS score.
//
// This member is required.
Metric *string
// The reason the CVSS score has been adjustment.
//
// This member is required.
Reason *string
noSmithyDocumentSerde
}
// Information about the CVSS score.
type CvssScoreDetails struct {
// The CVSS score.
//
// This member is required.
Score *float64
// The source for the CVSS score.
//
// This member is required.
ScoreSource *string
// The vector for the CVSS score.
//
// This member is required.
ScoringVector *string
// The CVSS version used in scoring.
//
// This member is required.
Version *string
// An object that contains details about adjustment Amazon Inspector made to the
// CVSS score.
Adjustments []CvssScoreAdjustment
// The source of the CVSS data.
CvssSource *string
noSmithyDocumentSerde
}
// Contains details on the time range used to filter findings.
type DateFilter struct {
// A timestamp representing the end of the time period filtered on.
EndInclusive *time.Time
// A timestamp representing the start of the time period filtered on.
StartInclusive *time.Time
noSmithyDocumentSerde
}
// Details of the Amazon Inspector delegated administrator for your organization.
type DelegatedAdmin struct {
// The Amazon Web Services account ID of the Amazon Inspector delegated
// administrator for your organization.
AccountId *string
// The status of the Amazon Inspector delegated administrator.
RelationshipStatus RelationshipStatus
noSmithyDocumentSerde
}
// Details of the Amazon Inspector delegated administrator for your organization.
type DelegatedAdminAccount struct {
// The Amazon Web Services account ID of the Amazon Inspector delegated
// administrator for your organization.
AccountId *string
// The status of the Amazon Inspector delegated administrator.
Status DelegatedAdminStatus
noSmithyDocumentSerde
}
// Contains details of the Amazon S3 bucket and KMS key used to export findings.
type Destination struct {
// The name of the Amazon S3 bucket to export findings to.
//
// This member is required.
BucketName *string
// The ARN of the KMS key used to encrypt data when exporting findings.
//
// This member is required.
KmsKeyArn *string
// The prefix of the Amazon S3 bucket used to export findings.
KeyPrefix *string
noSmithyDocumentSerde
}
// The details that define an aggregation based on Amazon EC2 instances.
type Ec2InstanceAggregation struct {
// The AMI IDs associated with the Amazon EC2 instances to aggregate findings for.
Amis []StringFilter
// The Amazon EC2 instance IDs to aggregate findings for.
InstanceIds []StringFilter
// The Amazon EC2 instance tags to aggregate findings for.
InstanceTags []MapFilter
// The operating system types to aggregate findings for. Valid values must be
// uppercase and underscore separated, examples are ORACLE_LINUX_7 and
// ALPINE_LINUX_3_8 .
OperatingSystems []StringFilter
// The value to sort results by.
SortBy Ec2InstanceSortBy
// The order to sort results by.
SortOrder SortOrder
noSmithyDocumentSerde
}
// A response that contains the results of a finding aggregation by Amazon EC2
// instance.
type Ec2InstanceAggregationResponse struct {
// The Amazon EC2 instance ID.
//
// This member is required.
InstanceId *string
// The Amazon Web Services account for the Amazon EC2 instance.
AccountId *string
// The Amazon Machine Image (AMI) of the Amazon EC2 instance.
Ami *string
// The tags attached to the instance.
InstanceTags map[string]string
// The number of network findings for the Amazon EC2 instance.
NetworkFindings *int64
// The operating system of the Amazon EC2 instance.
OperatingSystem *string
// An object that contains the count of matched findings per severity.
SeverityCounts *SeverityCounts
noSmithyDocumentSerde
}
// Meta data details of an Amazon EC2 instance.
type Ec2Metadata struct {
// The ID of the Amazon Machine Image (AMI) used to launch the instance.
AmiId *string
// The platform of the instance.
Platform Ec2Platform
// The tags attached to the instance.
Tags map[string]string
noSmithyDocumentSerde
}
// Details about the ECR automated re-scan duration setting for your environment.
type EcrConfiguration struct {
// The ECR automated re-scan duration defines how long an ECR image will be
// actively scanned by Amazon Inspector. When the number of days since an image was
// last pushed exceeds the automated re-scan duration the monitoring state of that
// image becomes inactive and all associated findings are scheduled for closure.
//
// This member is required.
RescanDuration EcrRescanDuration
noSmithyDocumentSerde
}
// Details about the state of the ECR scans for your environment.
type EcrConfigurationState struct {
// An object that contains details about the state of the ECR automated re-scan
// setting.
RescanDurationState *EcrRescanDurationState
noSmithyDocumentSerde
}
// Information on the Amazon ECR image metadata associated with a finding.
type EcrContainerImageMetadata struct {
// Tags associated with the Amazon ECR image metadata.
Tags []string
noSmithyDocumentSerde
}
// Information on the Amazon ECR repository metadata associated with a finding.
type EcrRepositoryMetadata struct {
// The name of the Amazon ECR repository.
Name *string
// The frequency of scans.
ScanFrequency EcrScanFrequency
noSmithyDocumentSerde
}
// Details about the state of any changes to the ECR automated re-scan duration
// setting.
type EcrRescanDurationState struct {
// The ECR automated re-scan duration defines how long an ECR image will be
// actively scanned by Amazon Inspector. When the number of days since an image was
// last pushed exceeds the automated re-scan duration the monitoring state of that
// image becomes inactive and all associated findings are scheduled for closure.
RescanDuration EcrRescanDuration
// The status of changes to the ECR automated re-scan duration.
Status EcrRescanDurationStatus
// A timestamp representing when the last time the ECR scan duration setting was
// changed.
UpdatedAt *time.Time
noSmithyDocumentSerde
}
// Details about the Exploit Prediction Scoring System (EPSS) score.
type Epss struct {
// The Exploit Prediction Scoring System (EPSS) score.
Score float64
noSmithyDocumentSerde
}
// Details about the Exploit Prediction Scoring System (EPSS) score for a finding.
type EpssDetails struct {
// The EPSS score.
Score float64
noSmithyDocumentSerde
}
// The details of an exploit available for a finding discovered in your
// environment.
type ExploitabilityDetails struct {
// The date and time of the last exploit associated with a finding discovered in
// your environment.
LastKnownExploitAt *time.Time
noSmithyDocumentSerde
}
// Contains information on when this exploit was observed.
type ExploitObserved struct {
// The date an time when the exploit was first seen.
FirstSeen *time.Time
// The date an time when the exploit was last seen.
LastSeen *time.Time
noSmithyDocumentSerde
}
// An object with details on why an account failed to enable Amazon Inspector.
type FailedAccount struct {
// The Amazon Web Services account ID.
//
// This member is required.
AccountId *string
// The error code explaining why the account failed to enable Amazon Inspector.
//
// This member is required.
ErrorCode ErrorCode
// The error message received when the account failed to enable Amazon Inspector.
//
// This member is required.
ErrorMessage *string
// An object detailing which resources Amazon Inspector is enabled to scan for the
// account.
ResourceStatus *ResourceStatus
// The status of Amazon Inspector for the account.
Status Status
noSmithyDocumentSerde
}
// An object that contains details about a member account in your organization
// that failed to activate Amazon Inspector deep inspection.
type FailedMemberAccountEc2DeepInspectionStatusState struct {
// The unique identifier for the Amazon Web Services account of the organization
// member that failed to activate Amazon Inspector deep inspection.
//
// This member is required.
AccountId *string
// The status of EC2 scanning in the account that failed to activate Amazon
// Inspector deep inspection.
Ec2ScanStatus Status
// The error message explaining why the account failed to activate Amazon
// Inspector deep inspection.
ErrorMessage *string
noSmithyDocumentSerde
}
// Details about a filter.
type Filter struct {
// The action that is to be applied to the findings that match the filter.
//
// This member is required.
Action FilterAction
// The Amazon Resource Number (ARN) associated with this filter.
//
// This member is required.
Arn *string
// The date and time this filter was created at.
//
// This member is required.
CreatedAt *time.Time
// Details on the filter criteria associated with this filter.
//
// This member is required.
Criteria *FilterCriteria
// The name of the filter.
//
// This member is required.
Name *string
// The Amazon Web Services account ID of the account that created the filter.
//
// This member is required.
OwnerId *string
// The date and time the filter was last updated at.
//
// This member is required.
UpdatedAt *time.Time
// A description of the filter.
Description *string
// The reason for the filter.
Reason *string
// The tags attached to the filter.
Tags map[string]string
noSmithyDocumentSerde
}
// Details on the criteria used to define the filter.
type FilterCriteria struct {
// Details of the Amazon Web Services account IDs used to filter findings.
AwsAccountId []StringFilter
// The name of the detector used to identify a code vulnerability in a Lambda
// function used to filter findings.
CodeVulnerabilityDetectorName []StringFilter
// The detector type tag associated with the vulnerability used to filter
// findings. Detector tags group related vulnerabilities by common themes or
// tactics. For a list of available tags by programming language, see Java tags (https://docs.aws.amazon.com/codeguru/detector-library/java/tags/)
// , or Python tags (https://docs.aws.amazon.com/codeguru/detector-library/python/tags/)
// .
CodeVulnerabilityDetectorTags []StringFilter
// The file path to the file in a Lambda function that contains a code
// vulnerability used to filter findings.
CodeVulnerabilityFilePath []StringFilter
// Details of the component IDs used to filter findings.
ComponentId []StringFilter
// Details of the component types used to filter findings.
ComponentType []StringFilter
// Details of the Amazon EC2 instance image IDs used to filter findings.
Ec2InstanceImageId []StringFilter
// Details of the Amazon EC2 instance subnet IDs used to filter findings.
Ec2InstanceSubnetId []StringFilter
// Details of the Amazon EC2 instance VPC IDs used to filter findings.
Ec2InstanceVpcId []StringFilter
// Details of the Amazon ECR image architecture types used to filter findings.
EcrImageArchitecture []StringFilter
// Details of the Amazon ECR image hashes used to filter findings.
EcrImageHash []StringFilter
// Details on the Amazon ECR image push date and time used to filter findings.
EcrImagePushedAt []DateFilter
// Details on the Amazon ECR registry used to filter findings.
EcrImageRegistry []StringFilter
// Details on the name of the Amazon ECR repository used to filter findings.
EcrImageRepositoryName []StringFilter
// The tags attached to the Amazon ECR container image.
EcrImageTags []StringFilter
// The EPSS score used to filter findings.
EpssScore []NumberFilter
// Filters the list of AWS Lambda findings by the availability of exploits.
ExploitAvailable []StringFilter
// Details on the finding ARNs used to filter findings.
FindingArn []StringFilter
// Details on the finding status types used to filter findings.
FindingStatus []StringFilter
// Details on the finding types used to filter findings.
FindingType []StringFilter
// Details on the date and time a finding was first seen used to filter findings.
FirstObservedAt []DateFilter
// Details on whether a fix is available through a version update. This value can
// be YES , NO , or PARTIAL . A PARTIAL fix means that some, but not all, of the
// packages identified in the finding have fixes available through updated
// versions.
FixAvailable []StringFilter
// The Amazon Inspector score to filter on.
InspectorScore []NumberFilter
// Filters the list of AWS Lambda functions by execution role.
LambdaFunctionExecutionRoleArn []StringFilter
// Filters the list of AWS Lambda functions by the date and time that a user last
// updated the configuration, in ISO 8601 format (https://www.iso.org/iso-8601-date-and-time-format.html)
LambdaFunctionLastModifiedAt []DateFilter
// Filters the list of AWS Lambda functions by the function's layers (https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html)
// . A Lambda function can have up to five layers.
LambdaFunctionLayers []StringFilter
// Filters the list of AWS Lambda functions by the name of the function.
LambdaFunctionName []StringFilter
// Filters the list of AWS Lambda functions by the runtime environment for the
// Lambda function.
LambdaFunctionRuntime []StringFilter
// Details on the date and time a finding was last seen used to filter findings.
LastObservedAt []DateFilter
// Details on the ingress source addresses used to filter findings.
NetworkProtocol []StringFilter
// Details on the port ranges used to filter findings.
PortRange []PortRangeFilter
// Details on the related vulnerabilities used to filter findings.
RelatedVulnerabilities []StringFilter
// Details on the resource IDs used to filter findings.
ResourceId []StringFilter
// Details on the resource tags used to filter findings.
ResourceTags []MapFilter
// Details on the resource types used to filter findings.
ResourceType []StringFilter
// Details on the severity used to filter findings.
Severity []StringFilter
// Details on the finding title used to filter findings.
Title []StringFilter
// Details on the date and time a finding was last updated at used to filter
// findings.
UpdatedAt []DateFilter
// Details on the vendor severity used to filter findings.
VendorSeverity []StringFilter
// Details on the vulnerability ID used to filter findings.
VulnerabilityId []StringFilter
// Details on the vulnerability type used to filter findings.
VulnerabilitySource []StringFilter
// Details on the vulnerable packages used to filter findings.
VulnerablePackages []PackageFilter
noSmithyDocumentSerde
}
// Details about an Amazon Inspector finding.
type Finding struct {
// The Amazon Web Services account ID associated with the finding.
//
// This member is required.
AwsAccountId *string
// The description of the finding.
//
// This member is required.
Description *string
// The Amazon Resource Number (ARN) of the finding.
//
// This member is required.
FindingArn *string
// The date and time that the finding was first observed.
//
// This member is required.
FirstObservedAt *time.Time
// The date and time that the finding was last observed.
//
// This member is required.
LastObservedAt *time.Time
// An object that contains the details about how to remediate a finding.
//
// This member is required.
Remediation *Remediation
// Contains information on the resources involved in a finding.
//
// This member is required.
Resources []Resource
// The severity of the finding.
//
// This member is required.
Severity Severity
// The status of the finding.
//
// This member is required.
Status FindingStatus
// The type of the finding.
//
// This member is required.
Type FindingType
// Details about the code vulnerability identified in a Lambda function used to
// filter findings.
CodeVulnerabilityDetails *CodeVulnerabilityDetails
// The finding's EPSS score.
Epss *EpssDetails
// If a finding discovered in your environment has an exploit available.
ExploitAvailable ExploitAvailable
// The details of an exploit available for a finding discovered in your
// environment.
ExploitabilityDetails *ExploitabilityDetails
// Details on whether a fix is available through a version update. This value can
// be YES , NO , or PARTIAL . A PARTIAL fix means that some, but not all, of the
// packages identified in the finding have fixes available through updated
// versions.
FixAvailable FixAvailable
// The Amazon Inspector score given to the finding.
InspectorScore *float64
// An object that contains details of the Amazon Inspector score.
InspectorScoreDetails *InspectorScoreDetails
// An object that contains the details of a network reachability finding.
NetworkReachabilityDetails *NetworkReachabilityDetails
// An object that contains the details of a package vulnerability finding.
PackageVulnerabilityDetails *PackageVulnerabilityDetails
// The title of the finding.
Title *string
// The date and time the finding was last updated at.
UpdatedAt *time.Time
noSmithyDocumentSerde
}
// The details that define an aggregation based on finding type.
type FindingTypeAggregation struct {
// The finding type to aggregate.
FindingType AggregationFindingType
// The resource type to aggregate.
ResourceType AggregationResourceType
// The value to sort results by.
SortBy FindingTypeSortBy
// The order to sort results by.
SortOrder SortOrder
noSmithyDocumentSerde
}
// A response that contains the results of a finding type aggregation.
type FindingTypeAggregationResponse struct {
// The ID of the Amazon Web Services account associated with the findings.
AccountId *string
// The value to sort results by.
SeverityCounts *SeverityCounts
noSmithyDocumentSerde
}
// Information about the Amazon Inspector free trial for an account.
type FreeTrialAccountInfo struct {
// The account associated with the Amazon Inspector free trial information.
//
// This member is required.
AccountId *string
// Contains information about the Amazon Inspector free trial for an account.
//
// This member is required.
FreeTrialInfo []FreeTrialInfo
noSmithyDocumentSerde
}
// An object that contains information about the Amazon Inspector free trial for
// an account.
type FreeTrialInfo struct {
// The date and time that the Amazon Inspector free trail ends for a given account.
//
// This member is required.
End *time.Time
// The date and time that the Amazon Inspector free trail started for a given
// account.
//
// This member is required.
Start *time.Time
// The order to sort results by.
//
// This member is required.
Status FreeTrialStatus
// The type of scan covered by the Amazon Inspector free trail.
//
// This member is required.
Type FreeTrialType
noSmithyDocumentSerde
}
// Information about an error received while accessing free trail data for an
// account.
type FreeTrialInfoError struct {
// The account associated with the Amazon Inspector free trial information.
//
// This member is required.
AccountId *string
// The error code.
//
// This member is required.
Code FreeTrialInfoErrorCode
// The error message returned.
//
// This member is required.
Message *string
noSmithyDocumentSerde
}
// The details that define an aggregation based on container image layers.
type ImageLayerAggregation struct {
// The hashes associated with the layers.
LayerHashes []StringFilter
// The repository associated with the container image hosting the layers.
Repositories []StringFilter
// The ID of the container image layer.
ResourceIds []StringFilter
// The value to sort results by.
SortBy ImageLayerSortBy
// The order to sort results by.
SortOrder SortOrder
noSmithyDocumentSerde
}
// A response that contains the results of a finding aggregation by image layer.
type ImageLayerAggregationResponse struct {
// The ID of the Amazon Web Services account that owns the container image hosting
// the layer image.
//
// This member is required.
AccountId *string
// The layer hash.
//
// This member is required.
LayerHash *string
// The repository the layer resides in.
//
// This member is required.
Repository *string
// The resource ID of the container image layer.
//
// This member is required.
ResourceId *string
// An object that represents the count of matched findings per severity.
SeverityCounts *SeverityCounts
noSmithyDocumentSerde
}
// Information about the Amazon Inspector score given to a finding.
type InspectorScoreDetails struct {
// An object that contains details about the CVSS score given to a finding.
AdjustedCvss *CvssScoreDetails
noSmithyDocumentSerde
}
// The details that define a findings aggregation based on AWS Lambda functions.
type LambdaFunctionAggregation struct {
// The AWS Lambda function names to include in the aggregation results.
FunctionNames []StringFilter
// The tags to include in the aggregation results.
FunctionTags []MapFilter
// The resource IDs to include in the aggregation results.
ResourceIds []StringFilter
// Returns findings aggregated by AWS Lambda function runtime environments.
Runtimes []StringFilter
// The finding severity to use for sorting the results.
SortBy LambdaFunctionSortBy
// The order to use for sorting the results.
SortOrder SortOrder
noSmithyDocumentSerde
}
// A response that contains the results of an AWS Lambda function finding
// aggregation.
type LambdaFunctionAggregationResponse struct {
// The resource IDs included in the aggregation results.
//
// This member is required.
ResourceId *string
// The ID of the AWS account that owns the AWS Lambda function.
AccountId *string
// The AWS Lambda function names included in the aggregation results.
FunctionName *string
// The tags included in the aggregation results.
LambdaTags map[string]string
// The date that the AWS Lambda function included in the aggregation results was
// last changed.
LastModifiedAt *time.Time
// The runtimes included in the aggregation results.
Runtime *string
// An object that contains the counts of aggregated finding per severity.
SeverityCounts *SeverityCounts
noSmithyDocumentSerde
}
// The AWS Lambda function metadata.
type LambdaFunctionMetadata struct {
// The name of a function.
FunctionName *string
// The resource tags on an AWS Lambda function.
FunctionTags map[string]string
// The layers for an AWS Lambda function. A Lambda function can have up to five
// layers.
Layers []string
// An AWS Lambda function's runtime.
Runtime Runtime
noSmithyDocumentSerde
}
// The details that define a findings aggregation based on an AWS Lambda
// function's layers.
type LambdaLayerAggregation struct {
// The names of the AWS Lambda functions associated with the layers.
FunctionNames []StringFilter
// The Amazon Resource Name (ARN) of the AWS Lambda function layer.
LayerArns []StringFilter
// The resource IDs for the AWS Lambda function layers.
ResourceIds []StringFilter
// The finding severity to use for sorting the results.
SortBy LambdaLayerSortBy
// The order to use for sorting the results.
SortOrder SortOrder
noSmithyDocumentSerde
}
// A response that contains the results of an AWS Lambda function layer finding
// aggregation.
type LambdaLayerAggregationResponse struct {
// The account ID of the AWS Lambda function layer.
//
// This member is required.
AccountId *string
// The names of the AWS Lambda functions associated with the layers.
//
// This member is required.
FunctionName *string
// The Amazon Resource Name (ARN) of the AWS Lambda function layer.
//
// This member is required.
LayerArn *string
// The Resource ID of the AWS Lambda function layer.
//
// This member is required.
ResourceId *string
// An object that contains the counts of aggregated finding per severity.
SeverityCounts *SeverityCounts
noSmithyDocumentSerde
}
// The VPC security groups and subnets that are attached to an AWS Lambda
// function. For more information, see VPC Settings (https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html)
// .
type LambdaVpcConfig struct {
// The VPC security groups and subnets that are attached to an AWS Lambda
// function. For more information, see VPC Settings (https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html)
// .
SecurityGroupIds []string
// A list of VPC subnet IDs.
SubnetIds []string
// The ID of the VPC.
VpcId *string
noSmithyDocumentSerde
}
// An object that describes details of a map filter.
type MapFilter struct {
// The operator to use when comparing values in the filter.
//
// This member is required.
Comparison MapComparison
// The tag key used in the filter.
//
// This member is required.
Key *string
// The tag value used in the filter.
Value *string
noSmithyDocumentSerde
}
// Details on a member account in your organization.
type Member struct {
// The Amazon Web Services account ID of the member account.
AccountId *string
// The Amazon Web Services account ID of the Amazon Inspector delegated
// administrator for this member account.
DelegatedAdminAccountId *string
// The status of the member account.
RelationshipStatus RelationshipStatus
// A timestamp showing when the status of this member was last updated.
UpdatedAt *time.Time
noSmithyDocumentSerde
}
// An object that contains details about the status of Amazon Inspector deep
// inspection for a member account in your organization.
type MemberAccountEc2DeepInspectionStatus struct {
// The unique identifier for the Amazon Web Services account of the organization
// member.
//
// This member is required.
AccountId *string
// Whether Amazon Inspector deep inspection is active in the account. If TRUE
// Amazon Inspector deep inspection is active, if FALSE it is not active.
//
// This member is required.
ActivateDeepInspection *bool
noSmithyDocumentSerde
}
// An object that contains details about the state of Amazon Inspector deep
// inspection for a member account.
type MemberAccountEc2DeepInspectionStatusState struct {
// The unique identifier for the Amazon Web Services account of the organization
// member
//
// This member is required.
AccountId *string
// The error message explaining why the account failed to activate Amazon
// Inspector deep inspection.
ErrorMessage *string
// The state of Amazon Inspector deep inspection in the member account.
Status Ec2DeepInspectionStatus
noSmithyDocumentSerde
}
// Information on the network path associated with a finding.
type NetworkPath struct {
// The details on the steps in the network path.
Steps []Step
noSmithyDocumentSerde
}
// Contains the details of a network reachability finding.
type NetworkReachabilityDetails struct {
// An object that contains details about a network path associated with a finding.
//
// This member is required.
NetworkPath *NetworkPath
// An object that contains details about the open port range associated with a
// finding.
//
// This member is required.
OpenPortRange *PortRange
// The protocol associated with a finding.
//
// This member is required.
Protocol NetworkProtocol
noSmithyDocumentSerde
}
// An object that describes the details of a number filter.
type NumberFilter struct {
// The lowest number to be included in the filter.
LowerInclusive *float64
// The highest number to be included in the filter.
UpperInclusive *float64
noSmithyDocumentSerde
}
// The details that define an aggregation based on operating system package type.
type PackageAggregation struct {
// The names of packages to aggregate findings on.
PackageNames []StringFilter
// The value to sort results by.
SortBy PackageSortBy
// The order to sort results by.
SortOrder SortOrder
noSmithyDocumentSerde
}
// A response that contains the results of a finding aggregation by image layer.
type PackageAggregationResponse struct {
// The name of the operating system package.
//
// This member is required.
PackageName *string
// The ID of the Amazon Web Services account associated with the findings.
AccountId *string
// An object that contains the count of matched findings per severity.
SeverityCounts *SeverityCounts
noSmithyDocumentSerde
}
// Contains information on the details of a package filter.
type PackageFilter struct {
// An object that contains details on the package architecture type to filter on.
Architecture *StringFilter
// An object that contains details on the package epoch to filter on.
Epoch *NumberFilter
// An object that contains details on the name of the package to filter on.
Name *StringFilter
// An object that contains details on the package release to filter on.
Release *StringFilter
// An object that describes the details of a string filter.
SourceLambdaLayerArn *StringFilter
// An object that contains details on the source layer hash to filter on.
SourceLayerHash *StringFilter
// The package version to filter on.
Version *StringFilter
noSmithyDocumentSerde
}
// Information about a package vulnerability finding.
type PackageVulnerabilityDetails struct {
// The source of the vulnerability information.
//
// This member is required.
Source *string
// The ID given to this vulnerability.
//
// This member is required.
VulnerabilityId *string
// An object that contains details about the CVSS score of a finding.
Cvss []CvssScore
// One or more URLs that contain details about this vulnerability type.
ReferenceUrls []string
// One or more vulnerabilities related to the one identified in this finding.
RelatedVulnerabilities []string
// A URL to the source of the vulnerability information.
SourceUrl *string
// The date and time that this vulnerability was first added to the vendor's
// database.
VendorCreatedAt *time.Time
// The severity the vendor has given to this vulnerability type.
VendorSeverity *string
// The date and time the vendor last updated this vulnerability in their database.
VendorUpdatedAt *time.Time
// The packages impacted by this vulnerability.
VulnerablePackages []VulnerablePackage
noSmithyDocumentSerde
}
// Contains information on the permissions an account has within Amazon Inspector.
type Permission struct {
// The operations that can be performed with the given permissions.
//
// This member is required.
Operation Operation
// The services that the permissions allow an account to perform the given
// operations for.
//
// This member is required.
Service Service
noSmithyDocumentSerde
}
// Details about the port range associated with a finding.
type PortRange struct {
// The beginning port in a port range.
//
// This member is required.
Begin *int32
// The ending port in a port range.
//
// This member is required.
End *int32
noSmithyDocumentSerde
}
// An object that describes the details of a port range filter.
type PortRangeFilter struct {
// The port number the port range begins at.
BeginInclusive *int32
// The port number the port range ends at.
EndInclusive *int32
noSmithyDocumentSerde
}
// Details about the recommended course of action to remediate the finding.
type Recommendation struct {
// The recommended course of action to remediate the finding.
Text *string
// The URL address to the CVE remediation recommendations.
Url *string
noSmithyDocumentSerde
}
// Information on how to remediate a finding.
type Remediation struct {
// An object that contains information about the recommended course of action to
// remediate the finding.
Recommendation *Recommendation
noSmithyDocumentSerde
}
// The details that define an aggregation based on repository.
type RepositoryAggregation struct {
// The names of repositories to aggregate findings on.
Repositories []StringFilter
// The value to sort results by.
SortBy RepositorySortBy
// The order to sort results by.
SortOrder SortOrder
noSmithyDocumentSerde
}
// A response that contains details on the results of a finding aggregation by
// repository.
type RepositoryAggregationResponse struct {
// The name of the repository associated with the findings.
//
// This member is required.
Repository *string
// The ID of the Amazon Web Services account associated with the findings.
AccountId *string
// The number of container images impacted by the findings.
AffectedImages *int64
// An object that represent the count of matched findings per severity.
SeverityCounts *SeverityCounts
noSmithyDocumentSerde
}
// Details about the resource involved in a finding.
type Resource struct {
// The ID of the resource.
//
// This member is required.
Id *string
// The type of resource.
//
// This member is required.
Type ResourceType
// An object that contains details about the resource involved in a finding.
Details *ResourceDetails
// The partition of the resource.
Partition *string
// The Amazon Web Services Region the impacted resource is located in.
Region *string
// The tags attached to the resource.
Tags map[string]string
noSmithyDocumentSerde
}
// Contains details about the resource involved in the finding.
type ResourceDetails struct {
// An object that contains details about the Amazon EC2 instance involved in the
// finding.
AwsEc2Instance *AwsEc2InstanceDetails
// An object that contains details about the Amazon ECR container image involved
// in the finding.
AwsEcrContainerImage *AwsEcrContainerImageDetails
// A summary of the information about an AWS Lambda function affected by a finding.
AwsLambdaFunction *AwsLambdaFunctionDetails
noSmithyDocumentSerde
}
// The resource filter criteria for a Software bill of materials (SBOM) report.
type ResourceFilterCriteria struct {
// The account IDs used as resource filter criteria.
AccountId []ResourceStringFilter
// The EC2 instance tags used as resource filter criteria.
Ec2InstanceTags []ResourceMapFilter
// The ECR image tags used as resource filter criteria.
EcrImageTags []ResourceStringFilter
// The ECR repository names used as resource filter criteria.
EcrRepositoryName []ResourceStringFilter
// The AWS Lambda function name used as resource filter criteria.
LambdaFunctionName []ResourceStringFilter
// The AWS Lambda function tags used as resource filter criteria.
LambdaFunctionTags []ResourceMapFilter
// The resource IDs used as resource filter criteria.
ResourceId []ResourceStringFilter
// The resource types used as resource filter criteria.
ResourceType []ResourceStringFilter
noSmithyDocumentSerde
}
// A resource map filter for a software bill of material report.
type ResourceMapFilter struct {
// The filter's comparison.
//
// This member is required.
Comparison ResourceMapComparison
// The filter's key.
//
// This member is required.
Key *string
// The filter's value.
Value *string
noSmithyDocumentSerde
}
// An object that contains details about the metadata for an Amazon ECR resource.
type ResourceScanMetadata struct {
// An object that contains metadata details for an Amazon EC2 instance.
Ec2 *Ec2Metadata
// An object that contains details about the container metadata for an Amazon ECR
// image.
EcrImage *EcrContainerImageMetadata
// An object that contains details about the repository an Amazon ECR image
// resides in.
EcrRepository *EcrRepositoryMetadata
// An object that contains metadata details for an AWS Lambda function.
LambdaFunction *LambdaFunctionMetadata
noSmithyDocumentSerde
}
// Details the state of Amazon Inspector for each resource type Amazon Inspector
// scans.
type ResourceState struct {
// An object detailing the state of Amazon Inspector scanning for Amazon EC2
// resources.
//
// This member is required.
Ec2 *State
// An object detailing the state of Amazon Inspector scanning for Amazon ECR
// resources.
//
// This member is required.
Ecr *State
// An object that described the state of Amazon Inspector scans for an account.
Lambda *State
// An object that described the state of Amazon Inspector scans for an account.
LambdaCode *State
noSmithyDocumentSerde
}
// Details the status of Amazon Inspector for each resource type Amazon Inspector
// scans.
type ResourceStatus struct {
// The status of Amazon Inspector scanning for Amazon EC2 resources.
//
// This member is required.
Ec2 Status
// The status of Amazon Inspector scanning for Amazon ECR resources.
//
// This member is required.
Ecr Status
// The status of Amazon Inspector scanning for AWS Lambda function.
Lambda Status
// The status of Amazon Inspector scanning for custom application code for Amazon
// Web Services Lambda functions.
LambdaCode Status
noSmithyDocumentSerde
}
// A resource string filter for a software bill of materials report.
type ResourceStringFilter struct {
// The filter's comparison.
//
// This member is required.
Comparison ResourceStringComparison
// The filter's value.
//
// This member is required.
Value *string
noSmithyDocumentSerde
}
// The status of the scan.
type ScanStatus struct {
// The reason for the scan.
//
// This member is required.
Reason ScanStatusReason
// The status code of the scan.
//
// This member is required.
StatusCode ScanStatusCode
noSmithyDocumentSerde
}
// Details on the criteria used to define the filter for a vulnerability search.
type SearchVulnerabilitiesFilterCriteria struct {
// The IDs for specific vulnerabilities.
//
// This member is required.
VulnerabilityIds []string
noSmithyDocumentSerde
}
// An object that contains the counts of aggregated finding per severity.
type SeverityCounts struct {
// The total count of findings from all severities.
All *int64
// The total count of critical severity findings.
Critical *int64
// The total count of high severity findings.
High *int64
// The total count of medium severity findings.
Medium *int64
noSmithyDocumentSerde
}
// Details about the criteria used to sort finding results.
type SortCriteria struct {
// The finding detail field by which results are sorted.
//
// This member is required.
Field SortField
// The order by which findings are sorted.
//
// This member is required.
SortOrder SortOrder
noSmithyDocumentSerde
}
// An object that described the state of Amazon Inspector scans for an account.
type State struct {
// The error code explaining why the account failed to enable Amazon Inspector.
//
// This member is required.
ErrorCode ErrorCode
// The error message received when the account failed to enable Amazon Inspector.
//
// This member is required.
ErrorMessage *string
// The status of Amazon Inspector for the account.
//
// This member is required.
Status Status
noSmithyDocumentSerde
}
// Details about the step associated with a finding.
type Step struct {
// The component ID.
//
// This member is required.
ComponentId *string
// The component type.
//
// This member is required.
ComponentType *string
noSmithyDocumentSerde
}
// An object that describes the details of a string filter.
type StringFilter struct {
// The operator to use when comparing values in the filter.
//
// This member is required.
Comparison StringComparison
// The value to filter on.
//
// This member is required.
Value *string
noSmithyDocumentSerde
}
// A suggested fix for a vulnerability in your Lambda function code.
type SuggestedFix struct {
// The fix's code.
Code *string
// The fix's description.
Description *string
noSmithyDocumentSerde
}
// The details that define an aggregation based on finding title.
type TitleAggregation struct {
// The type of finding to aggregate on.
FindingType AggregationFindingType
// The resource type to aggregate on.
ResourceType AggregationResourceType
// The value to sort results by.
SortBy TitleSortBy
// The order to sort results by.
SortOrder SortOrder
// The finding titles to aggregate on.
Titles []StringFilter
// The vulnerability IDs of the findings.
VulnerabilityIds []StringFilter
noSmithyDocumentSerde
}
// A response that contains details on the results of a finding aggregation by
// title.
type TitleAggregationResponse struct {
// The title that the findings were aggregated on.
//
// This member is required.
Title *string
// The ID of the Amazon Web Services account associated with the findings.
AccountId *string
// An object that represent the count of matched findings per severity.
SeverityCounts *SeverityCounts
// The vulnerability ID of the finding.
VulnerabilityId *string
noSmithyDocumentSerde
}
// Contains usage information about the cost of Amazon Inspector operation.
type Usage struct {
// The currency type used when calculating usage data.
Currency Currency
// The estimated monthly cost of Amazon Inspector.
EstimatedMonthlyCost float64
// The total of usage.
Total float64
// The type scan.
Type UsageType
noSmithyDocumentSerde
}
// The total of usage for an account ID.
type UsageTotal struct {
// The account ID of the account that usage data was retrieved for.
AccountId *string
// An object representing the total usage for an account.
Usage []Usage
noSmithyDocumentSerde
}
// An object that describes a validation exception.
type ValidationExceptionField struct {
// The validation exception message.
//
// This member is required.
Message *string
// The name of the validation exception.
//
// This member is required.
Name *string
noSmithyDocumentSerde
}
// Contains details about a specific vulnerability Amazon Inspector can detect.
type Vulnerability struct {
// The ID for the specific vulnerability.
//
// This member is required.
Id *string
// An object that contains information about the Amazon Web Services Threat Intel
// Group (ATIG) details for the vulnerability.
AtigData *AtigData
// An object that contains the Cybersecurity and Infrastructure Security Agency
// (CISA) details for the vulnerability.
CisaData *CisaData
// An object that contains the Common Vulnerability Scoring System (CVSS) Version
// 2 details for the vulnerability.
Cvss2 *Cvss2
// An object that contains the Common Vulnerability Scoring System (CVSS) Version
// 3 details for the vulnerability.
Cvss3 *Cvss3
// The Common Weakness Enumeration (CWE) associated with the vulnerability.
Cwes []string
// A description of the vulnerability.
Description *string
// Platforms that the vulnerability can be detected on.
DetectionPlatforms []string
// An object that contains the Exploit Prediction Scoring System (EPSS) score for
// a vulnerability.
Epss *Epss
// An object that contains details on when the exploit was observed.
ExploitObserved *ExploitObserved
// Links to various resources with more information on this vulnerability.
ReferenceUrls []string
// A list of related vulnerabilities.
RelatedVulnerabilities []string
// The source of the vulnerability information.
Source VulnerabilitySource
// A link to the official source material for this vulnerability.
SourceUrl *string
// The date and time when the vendor created this vulnerability.
VendorCreatedAt *time.Time
// The severity assigned by the vendor.
VendorSeverity *string
// The date and time when the vendor last updated this vulnerability.
VendorUpdatedAt *time.Time
noSmithyDocumentSerde
}
// Information on the vulnerable package identified by a finding.
type VulnerablePackage struct {
// The name of the vulnerable package.
//
// This member is required.
Name *string
// The version of the vulnerable package.
//
// This member is required.
Version *string
// The architecture of the vulnerable package.
Arch *string
// The epoch of the vulnerable package.
Epoch int32
// The file path of the vulnerable package.
FilePath *string
// The version of the package that contains the vulnerability fix.
FixedInVersion *string
// The package manager of the vulnerable package.
PackageManager PackageManager
// The release of the vulnerable package.
Release *string
// The code to run in your environment to update packages with a fix available.
Remediation *string
// The Amazon Resource Number (ARN) of the AWS Lambda function affected by a
// finding.
SourceLambdaLayerArn *string
// The source layer hash of the vulnerable package.
SourceLayerHash *string
noSmithyDocumentSerde
}
type noSmithyDocumentSerde = smithydocument.NoSerde
// UnknownUnionMember is returned when a union member is returned over the wire,
// but has an unknown tag.
type UnknownUnionMember struct {
Tag string
Value []byte
noSmithyDocumentSerde
}
func (*UnknownUnionMember) isAggregationRequest() {}
func (*UnknownUnionMember) isAggregationResponse() {}
| 2,709 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types_test
import (
"fmt"
"github.com/aws/aws-sdk-go-v2/service/inspector2/types"
)
func ExampleAggregationRequest_outputUsage() {
var union types.AggregationRequest
// type switches can be used to check the union value
switch v := union.(type) {
case *types.AggregationRequestMemberAccountAggregation:
_ = v.Value // Value is types.AccountAggregation
case *types.AggregationRequestMemberAmiAggregation:
_ = v.Value // Value is types.AmiAggregation
case *types.AggregationRequestMemberAwsEcrContainerAggregation:
_ = v.Value // Value is types.AwsEcrContainerAggregation
case *types.AggregationRequestMemberEc2InstanceAggregation:
_ = v.Value // Value is types.Ec2InstanceAggregation
case *types.AggregationRequestMemberFindingTypeAggregation:
_ = v.Value // Value is types.FindingTypeAggregation
case *types.AggregationRequestMemberImageLayerAggregation:
_ = v.Value // Value is types.ImageLayerAggregation
case *types.AggregationRequestMemberLambdaFunctionAggregation:
_ = v.Value // Value is types.LambdaFunctionAggregation
case *types.AggregationRequestMemberLambdaLayerAggregation:
_ = v.Value // Value is types.LambdaLayerAggregation
case *types.AggregationRequestMemberPackageAggregation:
_ = v.Value // Value is types.PackageAggregation
case *types.AggregationRequestMemberRepositoryAggregation:
_ = v.Value // Value is types.RepositoryAggregation
case *types.AggregationRequestMemberTitleAggregation:
_ = v.Value // Value is types.TitleAggregation
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.LambdaFunctionAggregation
var _ *types.LambdaLayerAggregation
var _ *types.AwsEcrContainerAggregation
var _ *types.TitleAggregation
var _ *types.ImageLayerAggregation
var _ *types.AmiAggregation
var _ *types.FindingTypeAggregation
var _ *types.AccountAggregation
var _ *types.Ec2InstanceAggregation
var _ *types.PackageAggregation
var _ *types.RepositoryAggregation
func ExampleAggregationResponse_outputUsage() {
var union types.AggregationResponse
// type switches can be used to check the union value
switch v := union.(type) {
case *types.AggregationResponseMemberAccountAggregation:
_ = v.Value // Value is types.AccountAggregationResponse
case *types.AggregationResponseMemberAmiAggregation:
_ = v.Value // Value is types.AmiAggregationResponse
case *types.AggregationResponseMemberAwsEcrContainerAggregation:
_ = v.Value // Value is types.AwsEcrContainerAggregationResponse
case *types.AggregationResponseMemberEc2InstanceAggregation:
_ = v.Value // Value is types.Ec2InstanceAggregationResponse
case *types.AggregationResponseMemberFindingTypeAggregation:
_ = v.Value // Value is types.FindingTypeAggregationResponse
case *types.AggregationResponseMemberImageLayerAggregation:
_ = v.Value // Value is types.ImageLayerAggregationResponse
case *types.AggregationResponseMemberLambdaFunctionAggregation:
_ = v.Value // Value is types.LambdaFunctionAggregationResponse
case *types.AggregationResponseMemberLambdaLayerAggregation:
_ = v.Value // Value is types.LambdaLayerAggregationResponse
case *types.AggregationResponseMemberPackageAggregation:
_ = v.Value // Value is types.PackageAggregationResponse
case *types.AggregationResponseMemberRepositoryAggregation:
_ = v.Value // Value is types.RepositoryAggregationResponse
case *types.AggregationResponseMemberTitleAggregation:
_ = v.Value // Value is types.TitleAggregationResponse
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
var _ *types.AccountAggregationResponse
var _ *types.AmiAggregationResponse
var _ *types.PackageAggregationResponse
var _ *types.RepositoryAggregationResponse
var _ *types.ImageLayerAggregationResponse
var _ *types.LambdaLayerAggregationResponse
var _ *types.TitleAggregationResponse
var _ *types.FindingTypeAggregationResponse
var _ *types.LambdaFunctionAggregationResponse
var _ *types.AwsEcrContainerAggregationResponse
var _ *types.Ec2InstanceAggregationResponse
| 125 |
aws-sdk-go-v2 | aws | Go | package acceptencoding
import (
"compress/gzip"
"context"
"fmt"
"io"
"github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
const acceptEncodingHeaderKey = "Accept-Encoding"
const contentEncodingHeaderKey = "Content-Encoding"
// AddAcceptEncodingGzipOptions provides the options for the
// AddAcceptEncodingGzip middleware setup.
type AddAcceptEncodingGzipOptions struct {
Enable bool
}
// AddAcceptEncodingGzip explicitly adds handling for accept-encoding GZIP
// middleware to the operation stack. This allows checksums to be correctly
// computed without disabling GZIP support.
func AddAcceptEncodingGzip(stack *middleware.Stack, options AddAcceptEncodingGzipOptions) error {
if options.Enable {
if err := stack.Finalize.Add(&EnableGzip{}, middleware.Before); err != nil {
return err
}
if err := stack.Deserialize.Insert(&DecompressGzip{}, "OperationDeserializer", middleware.After); err != nil {
return err
}
return nil
}
return stack.Finalize.Add(&DisableGzip{}, middleware.Before)
}
// DisableGzip provides the middleware that will
// disable the underlying http client automatically enabling for gzip
// decompress content-encoding support.
type DisableGzip struct{}
// ID returns the id for the middleware.
func (*DisableGzip) ID() string {
return "DisableAcceptEncodingGzip"
}
// HandleFinalize implements the FinalizeMiddleware interface.
func (*DisableGzip) HandleFinalize(
ctx context.Context, input middleware.FinalizeInput, next middleware.FinalizeHandler,
) (
output middleware.FinalizeOutput, metadata middleware.Metadata, err error,
) {
req, ok := input.Request.(*smithyhttp.Request)
if !ok {
return output, metadata, &smithy.SerializationError{
Err: fmt.Errorf("unknown request type %T", input.Request),
}
}
// Explicitly enable gzip support, this will prevent the http client from
// auto extracting the zipped content.
req.Header.Set(acceptEncodingHeaderKey, "identity")
return next.HandleFinalize(ctx, input)
}
// EnableGzip provides a middleware to enable support for
// gzip responses, with manual decompression. This prevents the underlying HTTP
// client from performing the gzip decompression automatically.
type EnableGzip struct{}
// ID returns the id for the middleware.
func (*EnableGzip) ID() string {
return "AcceptEncodingGzip"
}
// HandleFinalize implements the FinalizeMiddleware interface.
func (*EnableGzip) HandleFinalize(
ctx context.Context, input middleware.FinalizeInput, next middleware.FinalizeHandler,
) (
output middleware.FinalizeOutput, metadata middleware.Metadata, err error,
) {
req, ok := input.Request.(*smithyhttp.Request)
if !ok {
return output, metadata, &smithy.SerializationError{
Err: fmt.Errorf("unknown request type %T", input.Request),
}
}
// Explicitly enable gzip support, this will prevent the http client from
// auto extracting the zipped content.
req.Header.Set(acceptEncodingHeaderKey, "gzip")
return next.HandleFinalize(ctx, input)
}
// DecompressGzip provides the middleware for decompressing a gzip
// response from the service.
type DecompressGzip struct{}
// ID returns the id for the middleware.
func (*DecompressGzip) ID() string {
return "DecompressGzip"
}
// HandleDeserialize implements the DeserializeMiddlware interface.
func (*DecompressGzip) HandleDeserialize(
ctx context.Context, input middleware.DeserializeInput, next middleware.DeserializeHandler,
) (
output middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
output, metadata, err = next.HandleDeserialize(ctx, input)
if err != nil {
return output, metadata, err
}
resp, ok := output.RawResponse.(*smithyhttp.Response)
if !ok {
return output, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("unknown response type %T", output.RawResponse),
}
}
if v := resp.Header.Get(contentEncodingHeaderKey); v != "gzip" {
return output, metadata, err
}
// Clear content length since it will no longer be valid once the response
// body is decompressed.
resp.Header.Del("Content-Length")
resp.ContentLength = -1
resp.Body = wrapGzipReader(resp.Body)
return output, metadata, err
}
type gzipReader struct {
reader io.ReadCloser
gzip *gzip.Reader
}
func wrapGzipReader(reader io.ReadCloser) *gzipReader {
return &gzipReader{
reader: reader,
}
}
// Read wraps the gzip reader around the underlying io.Reader to extract the
// response bytes on the fly.
func (g *gzipReader) Read(b []byte) (n int, err error) {
if g.gzip == nil {
g.gzip, err = gzip.NewReader(g.reader)
if err != nil {
g.gzip = nil // ensure uninitialized gzip value isn't used in close.
return 0, fmt.Errorf("failed to decompress gzip response, %w", err)
}
}
return g.gzip.Read(b)
}
func (g *gzipReader) Close() error {
if g.gzip == nil {
return nil
}
if err := g.gzip.Close(); err != nil {
g.reader.Close()
return fmt.Errorf("failed to decompress gzip response, %w", err)
}
return g.reader.Close()
}
| 177 |
aws-sdk-go-v2 | aws | Go | package acceptencoding
import (
"bytes"
"compress/gzip"
"context"
"encoding/hex"
"io"
"io/ioutil"
"net/http"
"testing"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
func TestAddAcceptEncodingGzip(t *testing.T) {
cases := map[string]struct {
Enable bool
}{
"disabled": {
Enable: false,
},
"enabled": {
Enable: true,
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
stack := middleware.NewStack("test", smithyhttp.NewStackRequest)
stack.Deserialize.Add(&stubOpDeserializer{}, middleware.After)
AddAcceptEncodingGzip(stack, AddAcceptEncodingGzipOptions{
Enable: c.Enable,
})
id := "OperationDeserializer"
if m, ok := stack.Deserialize.Get(id); !ok || m == nil {
t.Fatalf("expect %s not to be removed", id)
}
if c.Enable {
id = (*EnableGzip)(nil).ID()
if m, ok := stack.Finalize.Get(id); !ok || m == nil {
t.Fatalf("expect %s to be present.", id)
}
id = (*DecompressGzip)(nil).ID()
if m, ok := stack.Deserialize.Get(id); !ok || m == nil {
t.Fatalf("expect %s to be present.", id)
}
return
}
id = (*EnableGzip)(nil).ID()
if m, ok := stack.Finalize.Get(id); ok || m != nil {
t.Fatalf("expect %s not to be present.", id)
}
id = (*DecompressGzip)(nil).ID()
if m, ok := stack.Deserialize.Get(id); ok || m != nil {
t.Fatalf("expect %s not to be present.", id)
}
})
}
}
func TestAcceptEncodingGzipMiddleware(t *testing.T) {
m := &EnableGzip{}
_, _, err := m.HandleFinalize(context.Background(),
middleware.FinalizeInput{
Request: smithyhttp.NewStackRequest(),
},
middleware.FinalizeHandlerFunc(
func(ctx context.Context, input middleware.FinalizeInput) (
output middleware.FinalizeOutput, metadata middleware.Metadata, err error,
) {
req, ok := input.Request.(*smithyhttp.Request)
if !ok || req == nil {
t.Fatalf("expect smithy request, got %T", input.Request)
}
actual := req.Header.Get(acceptEncodingHeaderKey)
if e, a := "gzip", actual; e != a {
t.Errorf("expect %v accept-encoding, got %v", e, a)
}
return output, metadata, err
}),
)
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
}
func TestDecompressGzipMiddleware(t *testing.T) {
cases := map[string]struct {
Response *smithyhttp.Response
ExpectBody []byte
ExpectContentLength int64
}{
"not compressed": {
Response: &smithyhttp.Response{
Response: &http.Response{
StatusCode: 200,
Header: http.Header{},
ContentLength: 2,
Body: &wasClosedReadCloser{
Reader: bytes.NewBuffer([]byte(`{}`)),
},
},
},
ExpectBody: []byte(`{}`),
ExpectContentLength: 2,
},
"compressed": {
Response: &smithyhttp.Response{
Response: &http.Response{
StatusCode: 200,
Header: http.Header{
contentEncodingHeaderKey: []string{"gzip"},
},
ContentLength: 10,
Body: func() io.ReadCloser {
var buf bytes.Buffer
w := gzip.NewWriter(&buf)
w.Write([]byte(`{}`))
w.Close()
return &wasClosedReadCloser{Reader: &buf}
}(),
},
},
ExpectBody: []byte(`{}`),
ExpectContentLength: -1, // Length empty because was decompressed
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
m := &DecompressGzip{}
var origRespBody io.Reader
output, _, err := m.HandleDeserialize(context.Background(),
middleware.DeserializeInput{},
middleware.DeserializeHandlerFunc(
func(ctx context.Context, input middleware.DeserializeInput) (
output middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
output.RawResponse = c.Response
origRespBody = c.Response.Body
return output, metadata, err
}),
)
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
resp, ok := output.RawResponse.(*smithyhttp.Response)
if !ok || resp == nil {
t.Fatalf("expect smithy request, got %T", output.RawResponse)
}
if e, a := c.ExpectContentLength, resp.ContentLength; e != a {
t.Errorf("expect %v content-length, got %v", e, a)
}
actual, err := ioutil.ReadAll(resp.Body)
if e, a := c.ExpectBody, actual; !bytes.Equal(e, a) {
t.Errorf("expect body equal\nexpect:\n%s\nactual:\n%s",
hex.Dump(e), hex.Dump(a))
}
if err := resp.Body.Close(); err != nil {
t.Fatalf("expect no close error, got %v", err)
}
if c, ok := origRespBody.(interface{ WasClosed() bool }); ok {
if !c.WasClosed() {
t.Errorf("expect original reader closed, but was not")
}
}
})
}
}
type stubOpDeserializer struct{}
func (*stubOpDeserializer) ID() string { return "OperationDeserializer" }
func (*stubOpDeserializer) HandleDeserialize(
ctx context.Context, input middleware.DeserializeInput, next middleware.DeserializeHandler,
) (
output middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
return next.HandleDeserialize(ctx, input)
}
type wasClosedReadCloser struct {
io.Reader
closed bool
}
func (c *wasClosedReadCloser) WasClosed() bool {
return c.closed
}
func (c *wasClosedReadCloser) Close() error {
c.closed = true
if v, ok := c.Reader.(io.Closer); ok {
return v.Close()
}
return nil
}
| 216 |
aws-sdk-go-v2 | aws | Go | /*
Package acceptencoding provides customizations associated with Accept Encoding Header.
# Accept encoding gzip
The Go HTTP client automatically supports accept-encoding and content-encoding
gzip by default. This default behavior is not desired by the SDK, and prevents
validating the response body's checksum. To prevent this the SDK must manually
control usage of content-encoding gzip.
To control content-encoding, the SDK must always set the `Accept-Encoding`
header to a value. This prevents the HTTP client from using gzip automatically.
When gzip is enabled on the API client, the SDK's customization will control
decompressing the gzip data in order to not break the checksum validation. When
gzip is disabled, the API client will disable gzip, preventing the HTTP
client's default behavior.
An `EnableAcceptEncodingGzip` option may or may not be present depending on the client using
the below middleware. The option if present can be used to enable auto decompressing
gzip by the SDK.
*/
package acceptencoding
| 23 |
aws-sdk-go-v2 | aws | Go | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT.
package acceptencoding
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.9.11"
| 7 |
aws-sdk-go-v2 | aws | Go | package benchmark
import (
"bytes"
"compress/gzip"
"context"
"fmt"
"io"
"io/ioutil"
"net/http"
"os"
"path/filepath"
"strconv"
"testing"
"github.com/aws/aws-sdk-go-v2/internal/awstesting/unit"
"github.com/aws/aws-sdk-go-v2/service/dynamodb"
awsOld "github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/corehandlers"
credsOld "github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/aws-sdk-go/aws/request"
"github.com/aws/aws-sdk-go/aws/session"
ddbOld "github.com/aws/aws-sdk-go/service/dynamodb"
)
type testData struct {
filename string
respChecksum int64
respGzipChecksum int64
}
func BenchmarkCustomizations(b *testing.B) {
cases := map[string]testData{
"small": {
filename: filepath.Join("testdata", "scan_response.short.json"),
respChecksum: 512691431,
respGzipChecksum: 891511383,
},
"large": {
filename: filepath.Join("testdata", "scan_response.json"),
respChecksum: 4158286593,
respGzipChecksum: 3095499784,
},
}
for name, c := range cases {
b.Run(name, func(b *testing.B) {
b.Run("old", func(b *testing.B) {
benchCustomizationsOld(b, c)
})
b.Run("smithy", func(b *testing.B) {
benchCustomizationsSmithy(b, c)
})
})
}
}
func benchCustomizationsOld(b *testing.B, c testData) {
_, body, err := loadBenchTestData(c.filename)
if err != nil {
b.Fatalf("failed to load test data, %s, %v", c.filename, err)
}
sess, err := session.NewSession(&awsOld.Config{
Credentials: credsOld.NewStaticCredentials("AKID", "SECRET", ""),
Region: awsOld.String("us-west-2"),
})
sess.Handlers.Send.SwapNamed(request.NamedHandler{
Name: corehandlers.SendHandler.Name,
Fn: func(r *request.Request) {
r.HTTPResponse = &http.Response{
StatusCode: 200,
Header: http.Header{
"X-Amz-Crc32": []string{strconv.FormatInt(c.respChecksum, 10)},
},
ContentLength: int64(len(body)),
Body: ioutil.NopCloser(bytes.NewReader(body)),
}
}})
if err != nil {
b.Fatalf("failed to load session, %v", err)
}
b.Run("default", func(b *testing.B) {
client := ddbOld.New(sess)
doBenchScanOld(b, client)
})
b.Run("none enabled", func(b *testing.B) {
client := ddbOld.New(sess, &awsOld.Config{
DisableComputeChecksums: awsOld.Bool(true),
})
doBenchScanOld(b, client)
})
}
func doBenchScanOld(b *testing.B, client *ddbOld.DynamoDB) {
b.Helper()
tableName := "mockTable"
params := ddbOld.ScanInput{
TableName: &tableName,
}
ctx := context.Background()
b.ResetTimer()
b.RunParallel(func(pb *testing.PB) {
for pb.Next() {
_, err := client.ScanWithContext(ctx, ¶ms)
if err != nil {
b.Fatalf("expect no error, %v", err)
}
}
})
}
func benchCustomizationsSmithy(b *testing.B, c testData) {
gzipBody, body, err := loadBenchTestData(c.filename)
if err != nil {
b.Fatalf("failed to load test data, %s, %v", c.filename, err)
}
options := dynamodb.Options{
Region: "us-west-2",
Credentials: unit.StubCredentialsProvider{},
HTTPClient: &mockClient{
ChecksumHeaderValue: []string{strconv.FormatInt(c.respChecksum, 10)},
ScanRespBody: body,
},
}
b.Run("default", func(b *testing.B) {
client := dynamodb.New(options)
doBenchScan(b, client)
})
b.Run("all enabled", func(b *testing.B) {
client := dynamodb.New(options, func(o *dynamodb.Options) {
o.HTTPClient = &mockClient{
ChecksumHeaderValue: []string{strconv.FormatInt(c.respGzipChecksum, 10)},
ScanRespGzipBody: gzipBody,
}
o.DisableValidateResponseChecksum = false
o.EnableAcceptEncodingGzip = true
})
doBenchScan(b, client)
})
b.Run("none enabled", func(b *testing.B) {
client := dynamodb.New(options, func(o *dynamodb.Options) {
o.DisableValidateResponseChecksum = true
o.EnableAcceptEncodingGzip = false
})
doBenchScan(b, client)
})
b.Run("checksum only", func(b *testing.B) {
client := dynamodb.New(options)
doBenchScan(b, client)
})
b.Run("gzip only", func(b *testing.B) {
client := dynamodb.New(options, func(o *dynamodb.Options) {
o.HTTPClient = &mockClient{
ScanRespGzipBody: gzipBody,
}
o.DisableValidateResponseChecksum = true
o.EnableAcceptEncodingGzip = true
})
doBenchScan(b, client)
})
}
type mockClient struct {
ChecksumHeaderValue []string
ScanRespGzipBody []byte
ScanRespBody []byte
}
func (m *mockClient) Do(r *http.Request) (*http.Response, error) {
resp := &http.Response{
StatusCode: 200,
Header: http.Header{
"Content-Type": []string{"application/x-amz-json-1.0"},
},
}
if m.ChecksumHeaderValue != nil {
resp.Header["X-Amz-Crc32"] = m.ChecksumHeaderValue
}
if m.ScanRespGzipBody != nil {
resp.Header["Content-Encoding"] = []string{"gzip"}
resp.ContentLength = int64(len(m.ScanRespGzipBody))
resp.Body = ioutil.NopCloser(bytes.NewReader(m.ScanRespGzipBody))
} else if m.ScanRespBody != nil {
resp.ContentLength = int64(len(m.ScanRespBody))
resp.Body = ioutil.NopCloser(bytes.NewReader(m.ScanRespBody))
} else {
return nil, fmt.Errorf("no client mock response body set")
}
return resp, nil
}
func doBenchScan(b *testing.B, client *dynamodb.Client) {
b.Helper()
tableName := "mockTable"
params := dynamodb.ScanInput{
TableName: &tableName,
}
ctx := context.Background()
b.ResetTimer()
b.RunParallel(func(pb *testing.PB) {
for pb.Next() {
_, err := client.Scan(ctx, ¶ms)
if err != nil {
b.Fatalf("expect no error, %v", err)
}
}
})
}
func loadBenchTestData(filename string) ([]byte, []byte, error) {
f, err := os.Open(filename)
if err != nil {
return nil, nil, fmt.Errorf("failed to open test data %v", err)
}
defer f.Close()
var body bytes.Buffer
if _, err := io.Copy(&body, f); err != nil {
return nil, nil, fmt.Errorf("failed to read test data %v", err)
}
var gzipBody bytes.Buffer
w := gzip.NewWriter(&gzipBody)
w.Write(body.Bytes())
w.Close()
return gzipBody.Bytes(), body.Bytes(), nil
}
| 254 |
aws-sdk-go-v2 | aws | Go | // Package benchmark provides benchmarks for the v2 SDK's Amazon DynamoDB API
// client.
//
// Includes benchmarks for the client's customizations, and compares the v2 SDK
// against the v1 SDK's legacy performance.
//
// Example command to run the benchmark
//
// go test -bench "/default" -run NONE -v -benchtime=10s -benchmem
package benchmark
| 11 |
aws-sdk-go-v2 | aws | Go | // Package benchmark provides benchmark tests for the AWS Lex runtime service
// generated API client.
package benchmark
| 4 |
aws-sdk-go-v2 | aws | Go | package benchmark
import (
"bytes"
"context"
"io/ioutil"
"net/http"
"path/filepath"
"testing"
"github.com/aws/aws-sdk-go-v2/internal/awstesting/unit"
smithyClient "github.com/aws/aws-sdk-go-v2/service/lexruntimeservice"
v1Aws "github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/corehandlers"
v1Creds "github.com/aws/aws-sdk-go/aws/credentials"
v1Request "github.com/aws/aws-sdk-go/aws/request"
v1Unit "github.com/aws/aws-sdk-go/awstesting/unit"
v1Client "github.com/aws/aws-sdk-go/service/lexruntimeservice"
"github.com/aws/smithy-go/ptr"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
func BenchmarkGetSession(b *testing.B) {
filename := filepath.Join("testdata", "get_session_resp.json")
bodyBytes, err := loadTestData(filename)
if err != nil {
b.Fatalf("failed to load test data, %s, %v", filename, err)
}
b.Run("old", func(b *testing.B) {
benchGetSessionOld(b, bodyBytes)
})
b.Run("smithy", func(b *testing.B) {
benchGetSessionSmithy(b, bodyBytes)
})
}
func benchGetSessionOld(b *testing.B, respBytes []byte) {
sess := v1Unit.Session.Copy(&v1Aws.Config{
Credentials: v1Creds.NewStaticCredentials("AKID", "SECRET", ""),
Region: ptr.String("us-west-2"),
})
sess.Handlers.Send.SwapNamed(v1Request.NamedHandler{
Name: corehandlers.SendHandler.Name,
Fn: func(r *v1Request.Request) {
r.HTTPResponse = newGetSessionHTTPResponse(respBytes)
},
})
client := v1Client.New(sess)
params := v1Client.GetSessionInput{
BotAlias: ptr.String("fooAlias"),
BotName: ptr.String("fooName"),
CheckpointLabelFilter: ptr.String("fooFilter"),
UserId: ptr.String("fooUser"),
}
ctx := context.Background()
b.ResetTimer()
b.RunParallel(func(pb *testing.PB) {
for pb.Next() {
_, err := client.GetSessionWithContext(ctx, ¶ms)
if err != nil {
b.Fatalf("failed to send request: %v", err)
}
}
})
}
func benchGetSessionSmithy(b *testing.B, respBytes []byte) {
var args []func(*smithyClient.Options)
if disableSmithySigning {
args = append(args, removeSmithySigner)
}
client := smithyClient.New(smithyClient.Options{
Region: "us-west-2",
Credentials: unit.StubCredentialsProvider{},
HTTPClient: smithyhttp.ClientDoFunc(
func(r *http.Request) (*http.Response, error) {
return newGetSessionHTTPResponse(respBytes), nil
}),
}, args...)
ctx := context.Background()
params := smithyClient.GetSessionInput{
BotAlias: ptr.String("fooAlias"),
BotName: ptr.String("fooName"),
CheckpointLabelFilter: ptr.String("fooFilter"),
UserId: ptr.String("fooUser"),
}
b.ResetTimer()
b.RunParallel(func(pb *testing.PB) {
for pb.Next() {
_, err := client.GetSession(ctx, ¶ms)
if err != nil {
b.Fatalf("failed to send: %v", err)
}
}
})
}
func newGetSessionHTTPResponse(body []byte) *http.Response {
return &http.Response{
StatusCode: 200,
Header: map[string][]string{
"Content-Type": {"application/json"},
},
ContentLength: int64(len(body)),
Body: ioutil.NopCloser(bytes.NewReader(body)),
}
}
| 116 |
aws-sdk-go-v2 | aws | Go | package benchmark
import (
"bytes"
"context"
"io/ioutil"
"net/http"
"testing"
"github.com/aws/aws-sdk-go-v2/internal/awstesting/unit"
smithyClient "github.com/aws/aws-sdk-go-v2/service/lexruntimeservice"
"github.com/aws/aws-sdk-go-v2/service/lexruntimeservice/types"
v1Aws "github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/corehandlers"
v1Creds "github.com/aws/aws-sdk-go/aws/credentials"
v1Request "github.com/aws/aws-sdk-go/aws/request"
v1Unit "github.com/aws/aws-sdk-go/awstesting/unit"
v1Client "github.com/aws/aws-sdk-go/service/lexruntimeservice"
"github.com/aws/smithy-go/ptr"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
func BenchmarkPutSession(b *testing.B) {
b.Run("old", func(b *testing.B) {
benchPutSessionOld(b)
})
b.Run("smithy", func(b *testing.B) {
benchPutSessionSmithy(b)
})
}
func benchPutSessionOld(b *testing.B) {
sess := v1Unit.Session.Copy(&v1Aws.Config{
Credentials: v1Creds.NewStaticCredentials("AKID", "SECRET", ""),
Region: ptr.String("us-west-2"),
})
sess.Handlers.Send.SwapNamed(v1Request.NamedHandler{
Name: corehandlers.SendHandler.Name,
Fn: func(r *v1Request.Request) {
r.HTTPResponse = newPutSessionHTTPResponse()
},
})
client := v1Client.New(sess)
ctx := context.Background()
params := v1Client.PutSessionInput{
Accept: ptr.String("text/plain"),
BotAlias: ptr.String("fooAlias"),
BotName: ptr.String("fooName"),
DialogAction: &v1Client.DialogAction{
FulfillmentState: ptr.String(v1Client.FulfillmentStateFulfilled),
IntentName: ptr.String("fooIntent"),
Message: ptr.String("fooMessage"),
MessageFormat: ptr.String(v1Client.MessageFormatTypePlainText),
SlotToElicit: ptr.String("fooSlot"),
Slots: ptr.StringMap(map[string]string{
"fooSlot": "fooValue",
"barSlot": "barValue",
}),
Type: ptr.String(v1Client.DialogActionTypeElicitSlot),
},
RecentIntentSummaryView: []*v1Client.IntentSummary{
{
CheckpointLabel: ptr.String("fooLabel"),
ConfirmationStatus: ptr.String(v1Client.ConfirmationStatusConfirmed),
DialogActionType: ptr.String(v1Client.DialogActionTypeElicitSlot),
FulfillmentState: ptr.String(v1Client.FulfillmentStateFulfilled),
IntentName: ptr.String("fooIntent"),
SlotToElicit: ptr.String("fooSlot"),
Slots: ptr.StringMap(map[string]string{
"fooSlot": "fooValue",
"barSlot": "barValue",
}),
},
},
SessionAttributes: ptr.StringMap(map[string]string{
"fooAttr": "fooValue",
}),
UserId: ptr.String("fooUser"),
}
b.ResetTimer()
b.RunParallel(func(pb *testing.PB) {
for pb.Next() {
_, err := client.PutSessionWithContext(ctx, ¶ms)
if err != nil {
b.Errorf("failed to send request: %v", err)
}
}
})
}
func benchPutSessionSmithy(b *testing.B) {
var args []func(*smithyClient.Options)
if disableSmithySigning {
args = append(args, removeSmithySigner)
}
client := smithyClient.New(smithyClient.Options{
Region: "us-west-2",
Credentials: unit.StubCredentialsProvider{},
HTTPClient: smithyhttp.ClientDoFunc(
func(r *http.Request) (*http.Response, error) {
return newPutSessionHTTPResponse(), nil
}),
}, args...)
ctx := context.Background()
params := smithyClient.PutSessionInput{
Accept: ptr.String("text/plain"),
BotAlias: ptr.String("fooAlias"),
BotName: ptr.String("fooName"),
DialogAction: &types.DialogAction{
FulfillmentState: types.FulfillmentStateFulfilled,
IntentName: ptr.String("fooIntent"),
Message: ptr.String("fooMessage"),
MessageFormat: types.MessageFormatTypePlainText,
SlotToElicit: ptr.String("fooSlot"),
Slots: map[string]string{
"fooSlot": "fooValue",
"barSlot": "barValue",
},
Type: types.DialogActionTypeElicitSlot,
},
RecentIntentSummaryView: []types.IntentSummary{
{
CheckpointLabel: ptr.String("fooLabel"),
ConfirmationStatus: types.ConfirmationStatusConfirmed,
DialogActionType: types.DialogActionTypeElicitSlot,
FulfillmentState: types.FulfillmentStateFulfilled,
IntentName: ptr.String("fooIntent"),
SlotToElicit: ptr.String("fooSlot"),
Slots: map[string]string{
"fooSlot": "fooValue",
"barSlot": "barValue",
},
},
},
SessionAttributes: map[string]string{
"fooAttr": "fooValue",
},
UserId: ptr.String("fooUser"),
}
b.ResetTimer()
b.RunParallel(func(pb *testing.PB) {
for pb.Next() {
_, err := client.PutSession(ctx, ¶ms)
if err != nil {
b.Errorf("failed to send request: %v", err)
}
}
})
}
var putSessionBody = []byte("fooAudioStream")
func newPutSessionHTTPResponse() *http.Response {
return &http.Response{
StatusCode: 200,
ContentLength: int64(len(putSessionBody)),
Header: map[string][]string{
"Content-Type": {"application/octet-stream"},
"x-amz-lex-dialog-state": {"Fulfilled"},
"x-amz-lex-intent-name": {"fooIntent"},
"x-amz-lex-message": {"fooMessage"},
"x-amz-lex-message-format": {"PlainText"},
"x-amz-lex-session-attributes": {"eyJmb29LZXkiOiAiZm9vVmFsdWUifQ=="},
"x-amz-lex-session-id": {"fooSession"},
"x-amz-lex-slot-to-elicit": {"fooSlot"},
"x-amz-lex-slots": {"eyJmb29LZXkiOiAiZm9vVmFsdWUifQ=="},
},
Body: ioutil.NopCloser(bytes.NewReader(putSessionBody)),
}
}
| 178 |
aws-sdk-go-v2 | aws | Go | package benchmark
import (
"bytes"
"flag"
"fmt"
"io"
"os"
"testing"
smithyClient "github.com/aws/aws-sdk-go-v2/service/lexruntimeservice"
"github.com/aws/smithy-go/middleware"
)
var (
disableSmithySigning bool
)
func init() {
flag.BoolVar(&disableSmithySigning, "disable-smithy-signing", false,
"Instructs the test to be run with smithy signing turned off.")
}
func TestMain(m *testing.M) {
flag.Parse()
os.Exit(m.Run())
}
func loadTestData(filename string) ([]byte, error) {
f, err := os.Open(filename)
if err != nil {
return nil, err
}
defer f.Close()
var b bytes.Buffer
if _, err = io.Copy(&b, f); err != nil {
return nil, fmt.Errorf("failed to read test data, %v", err)
}
return b.Bytes(), nil
}
func removeSmithySigner(options *smithyClient.Options) {
options.APIOptions = append(options.APIOptions, func(stack *middleware.Stack) error {
stack.Finalize.Remove("SigV4SignHTTPRequestMiddleware")
stack.Finalize.Remove("SigV4ContentSHA256HeaderMiddleware")
stack.Finalize.Remove("ComputePayloadSHA256Middleware")
stack.Finalize.Remove("SigV4UnsignedPayloadMiddleware")
return nil
})
}
| 54 |
aws-sdk-go-v2 | aws | Go | package s3
| 2 |
aws-sdk-go-v2 | aws | Go | package s3
import (
"context"
"io"
"io/ioutil"
"net/http"
"strings"
"testing"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/s3"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
func init() {
var s strings.Builder
io.Copy(&s, io.LimitReader(byteReader('a'), 1024*1024*12))
largeStringPayload = s.String()
}
type byteReader byte
func (b byteReader) Read(p []byte) (int, error) {
for i := 0; i < len(p); i++ {
p[i] = byte(b)
}
return len(p), nil
}
var largeStringPayload string
func BenchmarkGetBucketPolicy(b *testing.B) {
client := s3.New(s3.Options{
Region: "us-west-2",
HTTPClient: smithyhttp.ClientDoFunc(
func(r *http.Request) (*http.Response, error) {
return newGetBucketPolicyHTTPResponse(largeStringPayload), nil
}),
})
ctx := context.Background()
params := s3.GetBucketPolicyInput{
Bucket: aws.String("fooBucket"),
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
_, err := client.GetBucketPolicy(ctx, ¶ms)
if err != nil {
b.Fatalf("failed to send: %v", err)
}
}
}
func newGetBucketPolicyHTTPResponse(payload string) *http.Response {
return &http.Response{
StatusCode: 200,
Header: map[string][]string{
"Content-Type": {"application/json"},
},
ContentLength: int64(len(payload)),
Body: ioutil.NopCloser(strings.NewReader(payload)),
}
}
| 67 |
aws-sdk-go-v2 | aws | Go | package schemas
| 2 |
aws-sdk-go-v2 | aws | Go | package schemas
import (
"bytes"
"context"
"io/ioutil"
"net/http"
"testing"
"github.com/aws/aws-sdk-go-v2/service/schemas"
"github.com/aws/smithy-go/ptr"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
func init() {
largeBytePayload = make([]byte, 1024*1024*12)
}
var largeBytePayload []byte
func BenchmarkGetCodeBindingSource(b *testing.B) {
client := schemas.New(schemas.Options{
Region: "us-west-2",
HTTPClient: smithyhttp.ClientDoFunc(
func(r *http.Request) (*http.Response, error) {
return newGetCodeBindingSourceHTTPResponse(largeBytePayload), nil
}),
})
ctx := context.Background()
params := schemas.GetCodeBindingSourceInput{
Language: ptr.String("fooLanguage"),
RegistryName: ptr.String("fooRegistry"),
SchemaName: ptr.String("fooSchema"),
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
_, err := client.GetCodeBindingSource(ctx, ¶ms)
if err != nil {
b.Fatalf("failed to send: %v", err)
}
}
}
func newGetCodeBindingSourceHTTPResponse(payload []byte) *http.Response {
return &http.Response{
StatusCode: 200,
Header: map[string][]string{
"Content-Type": {"application/octet-stream"},
},
ContentLength: int64(len(payload)),
Body: ioutil.NopCloser(bytes.NewReader(payload)),
}
}
| 57 |
aws-sdk-go-v2 | aws | Go | package checksum
import (
"crypto/md5"
"crypto/sha1"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"fmt"
"hash"
"hash/crc32"
"io"
"strings"
"sync"
)
// Algorithm represents the checksum algorithms supported
type Algorithm string
// Enumeration values for supported checksum Algorithms.
const (
// AlgorithmCRC32C represents CRC32C hash algorithm
AlgorithmCRC32C Algorithm = "CRC32C"
// AlgorithmCRC32 represents CRC32 hash algorithm
AlgorithmCRC32 Algorithm = "CRC32"
// AlgorithmSHA1 represents SHA1 hash algorithm
AlgorithmSHA1 Algorithm = "SHA1"
// AlgorithmSHA256 represents SHA256 hash algorithm
AlgorithmSHA256 Algorithm = "SHA256"
)
var supportedAlgorithms = []Algorithm{
AlgorithmCRC32C,
AlgorithmCRC32,
AlgorithmSHA1,
AlgorithmSHA256,
}
func (a Algorithm) String() string { return string(a) }
// ParseAlgorithm attempts to parse the provided value into a checksum
// algorithm, matching without case. Returns the algorithm matched, or an error
// if the algorithm wasn't matched.
func ParseAlgorithm(v string) (Algorithm, error) {
for _, a := range supportedAlgorithms {
if strings.EqualFold(string(a), v) {
return a, nil
}
}
return "", fmt.Errorf("unknown checksum algorithm, %v", v)
}
// FilterSupportedAlgorithms filters the set of algorithms, returning a slice
// of algorithms that are supported.
func FilterSupportedAlgorithms(vs []string) []Algorithm {
found := map[Algorithm]struct{}{}
supported := make([]Algorithm, 0, len(supportedAlgorithms))
for _, v := range vs {
for _, a := range supportedAlgorithms {
// Only consider algorithms that are supported
if !strings.EqualFold(v, string(a)) {
continue
}
// Ignore duplicate algorithms in list.
if _, ok := found[a]; ok {
continue
}
supported = append(supported, a)
found[a] = struct{}{}
}
}
return supported
}
// NewAlgorithmHash returns a hash.Hash for the checksum algorithm. Error is
// returned if the algorithm is unknown.
func NewAlgorithmHash(v Algorithm) (hash.Hash, error) {
switch v {
case AlgorithmSHA1:
return sha1.New(), nil
case AlgorithmSHA256:
return sha256.New(), nil
case AlgorithmCRC32:
return crc32.NewIEEE(), nil
case AlgorithmCRC32C:
return crc32.New(crc32.MakeTable(crc32.Castagnoli)), nil
default:
return nil, fmt.Errorf("unknown checksum algorithm, %v", v)
}
}
// AlgorithmChecksumLength returns the length of the algorithm's checksum in
// bytes. If the algorithm is not known, an error is returned.
func AlgorithmChecksumLength(v Algorithm) (int, error) {
switch v {
case AlgorithmSHA1:
return sha1.Size, nil
case AlgorithmSHA256:
return sha256.Size, nil
case AlgorithmCRC32:
return crc32.Size, nil
case AlgorithmCRC32C:
return crc32.Size, nil
default:
return 0, fmt.Errorf("unknown checksum algorithm, %v", v)
}
}
const awsChecksumHeaderPrefix = "x-amz-checksum-"
// AlgorithmHTTPHeader returns the HTTP header for the algorithm's hash.
func AlgorithmHTTPHeader(v Algorithm) string {
return awsChecksumHeaderPrefix + strings.ToLower(string(v))
}
// base64EncodeHashSum computes base64 encoded checksum of a given running
// hash. The running hash must already have content written to it. Returns the
// byte slice of checksum and an error
func base64EncodeHashSum(h hash.Hash) []byte {
sum := h.Sum(nil)
sum64 := make([]byte, base64.StdEncoding.EncodedLen(len(sum)))
base64.StdEncoding.Encode(sum64, sum)
return sum64
}
// hexEncodeHashSum computes hex encoded checksum of a given running hash. The
// running hash must already have content written to it. Returns the byte slice
// of checksum and an error
func hexEncodeHashSum(h hash.Hash) []byte {
sum := h.Sum(nil)
sumHex := make([]byte, hex.EncodedLen(len(sum)))
hex.Encode(sumHex, sum)
return sumHex
}
// computeMD5Checksum computes base64 MD5 checksum of an io.Reader's contents.
// Returns the byte slice of MD5 checksum and an error.
func computeMD5Checksum(r io.Reader) ([]byte, error) {
h := md5.New()
// Copy errors may be assumed to be from the body.
if _, err := io.Copy(h, r); err != nil {
return nil, fmt.Errorf("failed compute MD5 hash of reader, %w", err)
}
// Encode the MD5 checksum in base64.
return base64EncodeHashSum(h), nil
}
// computeChecksumReader provides a reader wrapping an underlying io.Reader to
// compute the checksum of the stream's bytes.
type computeChecksumReader struct {
stream io.Reader
algorithm Algorithm
hasher hash.Hash
base64ChecksumLen int
mux sync.RWMutex
lockedChecksum string
lockedErr error
}
// newComputeChecksumReader returns a computeChecksumReader for the stream and
// algorithm specified. Returns error if unable to create the reader, or
// algorithm is unknown.
func newComputeChecksumReader(stream io.Reader, algorithm Algorithm) (*computeChecksumReader, error) {
hasher, err := NewAlgorithmHash(algorithm)
if err != nil {
return nil, err
}
checksumLength, err := AlgorithmChecksumLength(algorithm)
if err != nil {
return nil, err
}
return &computeChecksumReader{
stream: io.TeeReader(stream, hasher),
algorithm: algorithm,
hasher: hasher,
base64ChecksumLen: base64.StdEncoding.EncodedLen(checksumLength),
}, nil
}
// Read wraps the underlying reader. When the underlying reader returns EOF,
// the checksum of the reader will be computed, and can be retrieved with
// ChecksumBase64String.
func (r *computeChecksumReader) Read(p []byte) (int, error) {
n, err := r.stream.Read(p)
if err == nil {
return n, nil
} else if err != io.EOF {
r.mux.Lock()
defer r.mux.Unlock()
r.lockedErr = err
return n, err
}
b := base64EncodeHashSum(r.hasher)
r.mux.Lock()
defer r.mux.Unlock()
r.lockedChecksum = string(b)
return n, err
}
func (r *computeChecksumReader) Algorithm() Algorithm {
return r.algorithm
}
// Base64ChecksumLength returns the base64 encoded length of the checksum for
// algorithm.
func (r *computeChecksumReader) Base64ChecksumLength() int {
return r.base64ChecksumLen
}
// Base64Checksum returns the base64 checksum for the algorithm, or error if
// the underlying reader returned a non-EOF error.
//
// Safe to be called concurrently, but will return an error until after the
// underlying reader is returns EOF.
func (r *computeChecksumReader) Base64Checksum() (string, error) {
r.mux.RLock()
defer r.mux.RUnlock()
if r.lockedErr != nil {
return "", r.lockedErr
}
if r.lockedChecksum == "" {
return "", fmt.Errorf(
"checksum not available yet, called before reader returns EOF",
)
}
return r.lockedChecksum, nil
}
// validateChecksumReader implements io.ReadCloser interface. The wrapper
// performs checksum validation when the underlying reader has been fully read.
type validateChecksumReader struct {
originalBody io.ReadCloser
body io.Reader
hasher hash.Hash
algorithm Algorithm
expectChecksum string
}
// newValidateChecksumReader returns a configured io.ReadCloser that performs
// checksum validation when the underlying reader has been fully read.
func newValidateChecksumReader(
body io.ReadCloser,
algorithm Algorithm,
expectChecksum string,
) (*validateChecksumReader, error) {
hasher, err := NewAlgorithmHash(algorithm)
if err != nil {
return nil, err
}
return &validateChecksumReader{
originalBody: body,
body: io.TeeReader(body, hasher),
hasher: hasher,
algorithm: algorithm,
expectChecksum: expectChecksum,
}, nil
}
// Read attempts to read from the underlying stream while also updating the
// running hash. If the underlying stream returns with an EOF error, the
// checksum of the stream will be collected, and compared against the expected
// checksum. If the checksums do not match, an error will be returned.
//
// If a non-EOF error occurs when reading the underlying stream, that error
// will be returned and the checksum for the stream will be discarded.
func (c *validateChecksumReader) Read(p []byte) (n int, err error) {
n, err = c.body.Read(p)
if err == io.EOF {
if checksumErr := c.validateChecksum(); checksumErr != nil {
return n, checksumErr
}
}
return n, err
}
// Close closes the underlying reader, returning any error that occurred in the
// underlying reader.
func (c *validateChecksumReader) Close() (err error) {
return c.originalBody.Close()
}
func (c *validateChecksumReader) validateChecksum() error {
// Compute base64 encoded checksum hash of the payload's read bytes.
v := base64EncodeHashSum(c.hasher)
if e, a := c.expectChecksum, string(v); !strings.EqualFold(e, a) {
return validationError{
Algorithm: c.algorithm, Expect: e, Actual: a,
}
}
return nil
}
type validationError struct {
Algorithm Algorithm
Expect string
Actual string
}
func (v validationError) Error() string {
return fmt.Sprintf("checksum did not match: algorithm %v, expect %v, actual %v",
v.Algorithm, v.Expect, v.Actual)
}
| 324 |
aws-sdk-go-v2 | aws | Go | //go:build go1.16
// +build go1.16
package checksum
import (
"bytes"
"crypto/sha1"
"crypto/sha256"
"encoding/base64"
"fmt"
"hash/crc32"
"io"
"io/ioutil"
"strings"
"testing"
"testing/iotest"
"github.com/google/go-cmp/cmp"
)
func TestComputeChecksumReader(t *testing.T) {
cases := map[string]struct {
Input io.Reader
Algorithm Algorithm
ExpectErr string
ExpectChecksumLen int
ExpectRead string
ExpectReadErr string
ExpectComputeErr string
ExpectChecksum string
}{
"unknown algorithm": {
Input: bytes.NewBuffer(nil),
Algorithm: Algorithm("something"),
ExpectErr: "unknown checksum algorithm",
},
"read error": {
Input: iotest.ErrReader(fmt.Errorf("some error")),
Algorithm: AlgorithmSHA256,
ExpectChecksumLen: base64.StdEncoding.EncodedLen(sha256.Size),
ExpectReadErr: "some error",
ExpectComputeErr: "some error",
},
"crc32c": {
Input: strings.NewReader("hello world"),
Algorithm: AlgorithmCRC32C,
ExpectChecksumLen: base64.StdEncoding.EncodedLen(crc32.Size),
ExpectRead: "hello world",
ExpectChecksum: "yZRlqg==",
},
"crc32": {
Input: strings.NewReader("hello world"),
Algorithm: AlgorithmCRC32,
ExpectChecksumLen: base64.StdEncoding.EncodedLen(crc32.Size),
ExpectRead: "hello world",
ExpectChecksum: "DUoRhQ==",
},
"sha1": {
Input: strings.NewReader("hello world"),
Algorithm: AlgorithmSHA1,
ExpectChecksumLen: base64.StdEncoding.EncodedLen(sha1.Size),
ExpectRead: "hello world",
ExpectChecksum: "Kq5sNclPz7QV2+lfQIuc6R7oRu0=",
},
"sha256": {
Input: strings.NewReader("hello world"),
Algorithm: AlgorithmSHA256,
ExpectChecksumLen: base64.StdEncoding.EncodedLen(sha256.Size),
ExpectRead: "hello world",
ExpectChecksum: "uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=",
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
// Validate reader can be created as expected.
r, err := newComputeChecksumReader(c.Input, c.Algorithm)
if err == nil && len(c.ExpectErr) != 0 {
t.Fatalf("expect error %v, got none", c.ExpectErr)
}
if err != nil && len(c.ExpectErr) == 0 {
t.Fatalf("expect no error, got %v", err)
}
if err != nil && !strings.Contains(err.Error(), c.ExpectErr) {
t.Fatalf("expect error to contain %v, got %v", c.ExpectErr, err)
}
if c.ExpectErr != "" {
return
}
if e, a := c.Algorithm, r.Algorithm(); e != a {
t.Errorf("expect %v algorithm, got %v", e, a)
}
// Validate expected checksum length.
if e, a := c.ExpectChecksumLen, r.Base64ChecksumLength(); e != a {
t.Errorf("expect %v checksum length, got %v", e, a)
}
// Validate read reads underlying stream's bytes as expected.
b, err := ioutil.ReadAll(r)
if err == nil && len(c.ExpectReadErr) != 0 {
t.Fatalf("expect error %v, got none", c.ExpectReadErr)
}
if err != nil && len(c.ExpectReadErr) == 0 {
t.Fatalf("expect no error, got %v", err)
}
if err != nil && !strings.Contains(err.Error(), c.ExpectReadErr) {
t.Fatalf("expect error to contain %v, got %v", c.ExpectReadErr, err)
}
if len(c.ExpectReadErr) != 0 {
return
}
if diff := cmp.Diff(string(c.ExpectRead), string(b)); diff != "" {
t.Errorf("expect read match, got\n%v", diff)
}
// validate computed base64
v, err := r.Base64Checksum()
if err == nil && len(c.ExpectComputeErr) != 0 {
t.Fatalf("expect error %v, got none", c.ExpectComputeErr)
}
if err != nil && len(c.ExpectComputeErr) == 0 {
t.Fatalf("expect no error, got %v", err)
}
if err != nil && !strings.Contains(err.Error(), c.ExpectComputeErr) {
t.Fatalf("expect error to contain %v, got %v", c.ExpectComputeErr, err)
}
if diff := cmp.Diff(c.ExpectChecksum, v); diff != "" {
t.Errorf("expect checksum match, got\n%v", diff)
}
if c.ExpectComputeErr != "" {
return
}
if e, a := c.ExpectChecksumLen, len(v); e != a {
t.Errorf("expect computed checksum length %v, got %v", e, a)
}
})
}
}
func TestComputeChecksumReader_earlyGetChecksum(t *testing.T) {
r, err := newComputeChecksumReader(strings.NewReader("hello world"), AlgorithmCRC32C)
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
v, err := r.Base64Checksum()
if err == nil {
t.Fatalf("expect error, got none")
}
if err != nil && !strings.Contains(err.Error(), "not available") {
t.Fatalf("expect error to match, got %v", err)
}
if v != "" {
t.Errorf("expect no checksum, got %v", err)
}
}
// TODO race condition case with many reads, and get checksum
func TestValidateChecksumReader(t *testing.T) {
cases := map[string]struct {
payload io.ReadCloser
algorithm Algorithm
checksum string
expectErr string
expectChecksumErr string
expectedBody []byte
}{
"unknown algorithm": {
payload: ioutil.NopCloser(bytes.NewBuffer(nil)),
algorithm: Algorithm("something"),
expectErr: "unknown checksum algorithm",
},
"empty body": {
payload: ioutil.NopCloser(bytes.NewReader([]byte(""))),
algorithm: AlgorithmCRC32,
checksum: "AAAAAA==",
expectedBody: []byte(""),
},
"standard body": {
payload: ioutil.NopCloser(bytes.NewReader([]byte("Hello world"))),
algorithm: AlgorithmCRC32,
checksum: "i9aeUg==",
expectedBody: []byte("Hello world"),
},
"checksum mismatch": {
payload: ioutil.NopCloser(bytes.NewReader([]byte("Hello world"))),
algorithm: AlgorithmCRC32,
checksum: "AAAAAA==",
expectedBody: []byte("Hello world"),
expectChecksumErr: "checksum did not match",
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
response, err := newValidateChecksumReader(c.payload, c.algorithm, c.checksum)
if err == nil && len(c.expectErr) != 0 {
t.Fatalf("expect error %v, got none", c.expectErr)
}
if err != nil && len(c.expectErr) == 0 {
t.Fatalf("expect no error, got %v", err)
}
if err != nil && !strings.Contains(err.Error(), c.expectErr) {
t.Fatalf("expect error to contain %v, got %v", c.expectErr, err)
}
if c.expectErr != "" {
return
}
if response == nil {
if c.expectedBody == nil {
return
}
t.Fatalf("expected non nil response, got nil")
}
actualResponse, err := ioutil.ReadAll(response)
if err == nil && len(c.expectChecksumErr) != 0 {
t.Fatalf("expected error %v, got none", c.expectChecksumErr)
}
if err != nil && !strings.Contains(err.Error(), c.expectChecksumErr) {
t.Fatalf("expected error %v to contain %v", err.Error(), c.expectChecksumErr)
}
if diff := cmp.Diff(c.expectedBody, actualResponse); len(diff) != 0 {
t.Fatalf("found diff comparing response body %v", diff)
}
err = response.Close()
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
})
}
}
func TestComputeMD5Checksum(t *testing.T) {
cases := map[string]struct {
payload io.Reader
expectErr string
expectChecksum string
}{
"empty payload": {
payload: strings.NewReader(""),
expectChecksum: "1B2M2Y8AsgTpgAmY7PhCfg==",
},
"payload": {
payload: strings.NewReader("hello world"),
expectChecksum: "XrY7u+Ae7tCTyyK7j1rNww==",
},
"error payload": {
payload: iotest.ErrReader(fmt.Errorf("some error")),
expectErr: "some error",
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
actualChecksum, err := computeMD5Checksum(c.payload)
if err == nil && len(c.expectErr) != 0 {
t.Fatalf("expect error %v, got none", c.expectErr)
}
if err != nil && len(c.expectErr) == 0 {
t.Fatalf("expect no error, got %v", err)
}
if err != nil && !strings.Contains(err.Error(), c.expectErr) {
t.Fatalf("expect error to contain %v, got %v", c.expectErr, err)
}
if c.expectErr != "" {
return
}
if e, a := c.expectChecksum, string(actualChecksum); !strings.EqualFold(e, a) {
t.Errorf("expect %v checksum, got %v", e, a)
}
})
}
}
func TestParseAlgorithm(t *testing.T) {
cases := map[string]struct {
Value string
expectAlgorithm Algorithm
expectErr string
}{
"crc32c": {
Value: "crc32c",
expectAlgorithm: AlgorithmCRC32C,
},
"CRC32C": {
Value: "CRC32C",
expectAlgorithm: AlgorithmCRC32C,
},
"crc32": {
Value: "crc32",
expectAlgorithm: AlgorithmCRC32,
},
"CRC32": {
Value: "CRC32",
expectAlgorithm: AlgorithmCRC32,
},
"sha1": {
Value: "sha1",
expectAlgorithm: AlgorithmSHA1,
},
"SHA1": {
Value: "SHA1",
expectAlgorithm: AlgorithmSHA1,
},
"sha256": {
Value: "sha256",
expectAlgorithm: AlgorithmSHA256,
},
"SHA256": {
Value: "SHA256",
expectAlgorithm: AlgorithmSHA256,
},
"empty": {
Value: "",
expectErr: "unknown checksum algorithm",
},
"unknown": {
Value: "unknown",
expectErr: "unknown checksum algorithm",
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
// Asserts
algorithm, err := ParseAlgorithm(c.Value)
if err == nil && len(c.expectErr) != 0 {
t.Fatalf("expect error %v, got none", c.expectErr)
}
if err != nil && len(c.expectErr) == 0 {
t.Fatalf("expect no error, got %v", err)
}
if err != nil && !strings.Contains(err.Error(), c.expectErr) {
t.Fatalf("expect error to contain %v, got %v", c.expectErr, err)
}
if c.expectErr != "" {
return
}
if e, a := c.expectAlgorithm, algorithm; e != a {
t.Errorf("expect %v algorithm, got %v", e, a)
}
})
}
}
func TestFilterSupportedAlgorithms(t *testing.T) {
cases := map[string]struct {
values []string
expectAlgorithms []Algorithm
}{
"no algorithms": {
expectAlgorithms: []Algorithm{},
},
"no supported algorithms": {
values: []string{"abc", "123"},
expectAlgorithms: []Algorithm{},
},
"duplicate algorithms": {
values: []string{"crc32", "crc32c", "crc32c"},
expectAlgorithms: []Algorithm{
AlgorithmCRC32,
AlgorithmCRC32C,
},
},
"preserve order": {
values: []string{"crc32", "crc32c", "sha1", "sha256"},
expectAlgorithms: []Algorithm{
AlgorithmCRC32,
AlgorithmCRC32C,
AlgorithmSHA1,
AlgorithmSHA256,
},
},
"preserve order 2": {
values: []string{"sha256", "crc32", "sha1", "crc32c"},
expectAlgorithms: []Algorithm{
AlgorithmSHA256,
AlgorithmCRC32,
AlgorithmSHA1,
AlgorithmCRC32C,
},
},
"mixed case": {
values: []string{"Crc32", "cRc32c", "shA1", "sHA256"},
expectAlgorithms: []Algorithm{
AlgorithmCRC32,
AlgorithmCRC32C,
AlgorithmSHA1,
AlgorithmSHA256,
},
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
algorithms := FilterSupportedAlgorithms(c.values)
if diff := cmp.Diff(c.expectAlgorithms, algorithms); diff != "" {
t.Errorf("expect algorithms match\n%s", diff)
}
})
}
}
func TestAlgorithmChecksumLength(t *testing.T) {
cases := map[string]struct {
algorithm Algorithm
expectErr string
expectLength int
}{
"empty": {
algorithm: "",
expectErr: "unknown checksum algorithm",
},
"unknown": {
algorithm: "",
expectErr: "unknown checksum algorithm",
},
"crc32": {
algorithm: AlgorithmCRC32,
expectLength: crc32.Size,
},
"crc32c": {
algorithm: AlgorithmCRC32C,
expectLength: crc32.Size,
},
"sha1": {
algorithm: AlgorithmSHA1,
expectLength: sha1.Size,
},
"sha256": {
algorithm: AlgorithmSHA256,
expectLength: sha256.Size,
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
l, err := AlgorithmChecksumLength(c.algorithm)
if err == nil && len(c.expectErr) != 0 {
t.Fatalf("expect error %v, got none", c.expectErr)
}
if err != nil && len(c.expectErr) == 0 {
t.Fatalf("expect no error, got %v", err)
}
if err != nil && !strings.Contains(err.Error(), c.expectErr) {
t.Fatalf("expect error to contain %v, got %v", c.expectErr, err)
}
if c.expectErr != "" {
return
}
if e, a := c.expectLength, l; e != a {
t.Errorf("expect %v checksum length, got %v", e, a)
}
})
}
}
| 471 |
aws-sdk-go-v2 | aws | Go | package checksum
import (
"bytes"
"fmt"
"io"
"strconv"
"strings"
)
const (
crlf = "\r\n"
// https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-streaming.html
defaultChunkLength = 1024 * 64
awsTrailerHeaderName = "x-amz-trailer"
decodedContentLengthHeaderName = "x-amz-decoded-content-length"
contentEncodingHeaderName = "content-encoding"
awsChunkedContentEncodingHeaderValue = "aws-chunked"
trailerKeyValueSeparator = ":"
)
var (
crlfBytes = []byte(crlf)
finalChunkBytes = []byte("0" + crlf)
)
type awsChunkedEncodingOptions struct {
// The total size of the stream. For unsigned encoding this implies that
// there will only be a single chunk containing the underlying payload,
// unless ChunkLength is also specified.
StreamLength int64
// Set of trailer key:value pairs that will be appended to the end of the
// payload after the end chunk has been written.
Trailers map[string]awsChunkedTrailerValue
// The maximum size of each chunk to be sent. Default value of -1, signals
// that optimal chunk length will be used automatically. ChunkSize must be
// at least 8KB.
//
// If ChunkLength and StreamLength are both specified, the stream will be
// broken up into ChunkLength chunks. The encoded length of the aws-chunked
// encoding can still be determined as long as all trailers, if any, have a
// fixed length.
ChunkLength int
}
type awsChunkedTrailerValue struct {
// Function to retrieve the value of the trailer. Will only be called after
// the underlying stream returns EOF error.
Get func() (string, error)
// If the length of the value can be pre-determined, and is constant
// specify the length. A value of -1 means the length is unknown, or
// cannot be pre-determined.
Length int
}
// awsChunkedEncoding provides a reader that wraps the payload such that
// payload is read as a single aws-chunk payload. This reader can only be used
// if the content length of payload is known. Content-Length is used as size of
// the single payload chunk. The final chunk and trailing checksum is appended
// at the end.
//
// https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-streaming.html#sigv4-chunked-body-definition
//
// Here is the aws-chunked payload stream as read from the awsChunkedEncoding
// if original request stream is "Hello world", and checksum hash used is SHA256
//
// <b>\r\n
// Hello world\r\n
// 0\r\n
// x-amz-checksum-sha256:ZOyIygCyaOW6GjVnihtTFtIS9PNmskdyMlNKiuyjfzw=\r\n
// \r\n
type awsChunkedEncoding struct {
options awsChunkedEncodingOptions
encodedStream io.Reader
trailerEncodedLength int
}
// newUnsignedAWSChunkedEncoding returns a new awsChunkedEncoding configured
// for unsigned aws-chunked content encoding. Any additional trailers that need
// to be appended after the end chunk must be included as via Trailer
// callbacks.
func newUnsignedAWSChunkedEncoding(
stream io.Reader,
optFns ...func(*awsChunkedEncodingOptions),
) *awsChunkedEncoding {
options := awsChunkedEncodingOptions{
Trailers: map[string]awsChunkedTrailerValue{},
StreamLength: -1,
ChunkLength: -1,
}
for _, fn := range optFns {
fn(&options)
}
var chunkReader io.Reader
if options.ChunkLength != -1 || options.StreamLength == -1 {
if options.ChunkLength == -1 {
options.ChunkLength = defaultChunkLength
}
chunkReader = newBufferedAWSChunkReader(stream, options.ChunkLength)
} else {
chunkReader = newUnsignedChunkReader(stream, options.StreamLength)
}
trailerReader := newAWSChunkedTrailerReader(options.Trailers)
return &awsChunkedEncoding{
options: options,
encodedStream: io.MultiReader(chunkReader,
trailerReader,
bytes.NewBuffer(crlfBytes),
),
trailerEncodedLength: trailerReader.EncodedLength(),
}
}
// EncodedLength returns the final length of the aws-chunked content encoded
// stream if it can be determined without reading the underlying stream or lazy
// header values, otherwise -1 is returned.
func (e *awsChunkedEncoding) EncodedLength() int64 {
var length int64
if e.options.StreamLength == -1 || e.trailerEncodedLength == -1 {
return -1
}
if e.options.StreamLength != 0 {
// If the stream length is known, and there is no chunk length specified,
// only a single chunk will be used. Otherwise the stream length needs to
// include the multiple chunk padding content.
if e.options.ChunkLength == -1 {
length += getUnsignedChunkBytesLength(e.options.StreamLength)
} else {
// Compute chunk header and payload length
numChunks := e.options.StreamLength / int64(e.options.ChunkLength)
length += numChunks * getUnsignedChunkBytesLength(int64(e.options.ChunkLength))
if remainder := e.options.StreamLength % int64(e.options.ChunkLength); remainder != 0 {
length += getUnsignedChunkBytesLength(remainder)
}
}
}
// End chunk
length += int64(len(finalChunkBytes))
// Trailers
length += int64(e.trailerEncodedLength)
// Encoding terminator
length += int64(len(crlf))
return length
}
func getUnsignedChunkBytesLength(payloadLength int64) int64 {
payloadLengthStr := strconv.FormatInt(payloadLength, 16)
return int64(len(payloadLengthStr)) + int64(len(crlf)) + payloadLength + int64(len(crlf))
}
// HTTPHeaders returns the set of headers that must be included the request for
// aws-chunked to work. This includes the content-encoding: aws-chunked header.
//
// If there are multiple layered content encoding, the aws-chunked encoding
// must be appended to the previous layers the stream's encoding. The best way
// to do this is to append all header values returned to the HTTP request's set
// of headers.
func (e *awsChunkedEncoding) HTTPHeaders() map[string][]string {
headers := map[string][]string{
contentEncodingHeaderName: {
awsChunkedContentEncodingHeaderValue,
},
}
if len(e.options.Trailers) != 0 {
trailers := make([]string, 0, len(e.options.Trailers))
for name := range e.options.Trailers {
trailers = append(trailers, strings.ToLower(name))
}
headers[awsTrailerHeaderName] = trailers
}
return headers
}
func (e *awsChunkedEncoding) Read(b []byte) (n int, err error) {
return e.encodedStream.Read(b)
}
// awsChunkedTrailerReader provides a lazy reader for reading of aws-chunked
// content encoded trailers. The trailer values will not be retrieved until the
// reader is read from.
type awsChunkedTrailerReader struct {
reader *bytes.Buffer
trailers map[string]awsChunkedTrailerValue
trailerEncodedLength int
}
// newAWSChunkedTrailerReader returns an initialized awsChunkedTrailerReader to
// lazy reading aws-chunk content encoded trailers.
func newAWSChunkedTrailerReader(trailers map[string]awsChunkedTrailerValue) *awsChunkedTrailerReader {
return &awsChunkedTrailerReader{
trailers: trailers,
trailerEncodedLength: trailerEncodedLength(trailers),
}
}
func trailerEncodedLength(trailers map[string]awsChunkedTrailerValue) (length int) {
for name, trailer := range trailers {
length += len(name) + len(trailerKeyValueSeparator)
l := trailer.Length
if l == -1 {
return -1
}
length += l + len(crlf)
}
return length
}
// EncodedLength returns the length of the encoded trailers if the length could
// be determined without retrieving the header values. Returns -1 if length is
// unknown.
func (r *awsChunkedTrailerReader) EncodedLength() (length int) {
return r.trailerEncodedLength
}
// Read populates the passed in byte slice with bytes from the encoded
// trailers. Will lazy read header values first time Read is called.
func (r *awsChunkedTrailerReader) Read(p []byte) (int, error) {
if r.trailerEncodedLength == 0 {
return 0, io.EOF
}
if r.reader == nil {
trailerLen := r.trailerEncodedLength
if r.trailerEncodedLength == -1 {
trailerLen = 0
}
r.reader = bytes.NewBuffer(make([]byte, 0, trailerLen))
for name, trailer := range r.trailers {
r.reader.WriteString(name)
r.reader.WriteString(trailerKeyValueSeparator)
v, err := trailer.Get()
if err != nil {
return 0, fmt.Errorf("failed to get trailer value, %w", err)
}
r.reader.WriteString(v)
r.reader.WriteString(crlf)
}
}
return r.reader.Read(p)
}
// newUnsignedChunkReader returns an io.Reader encoding the underlying reader
// as unsigned aws-chunked chunks. The returned reader will also include the
// end chunk, but not the aws-chunked final `crlf` segment so trailers can be
// added.
//
// If the payload size is -1 for unknown length the content will be buffered in
// defaultChunkLength chunks before wrapped in aws-chunked chunk encoding.
func newUnsignedChunkReader(reader io.Reader, payloadSize int64) io.Reader {
if payloadSize == -1 {
return newBufferedAWSChunkReader(reader, defaultChunkLength)
}
var endChunk bytes.Buffer
if payloadSize == 0 {
endChunk.Write(finalChunkBytes)
return &endChunk
}
endChunk.WriteString(crlf)
endChunk.Write(finalChunkBytes)
var header bytes.Buffer
header.WriteString(strconv.FormatInt(payloadSize, 16))
header.WriteString(crlf)
return io.MultiReader(
&header,
reader,
&endChunk,
)
}
// Provides a buffered aws-chunked chunk encoder of an underlying io.Reader.
// Will include end chunk, but not the aws-chunked final `crlf` segment so
// trailers can be added.
//
// Note does not implement support for chunk extensions, e.g. chunk signing.
type bufferedAWSChunkReader struct {
reader io.Reader
chunkSize int
chunkSizeStr string
headerBuffer *bytes.Buffer
chunkBuffer *bytes.Buffer
multiReader io.Reader
multiReaderLen int
endChunkDone bool
}
// newBufferedAWSChunkReader returns an bufferedAWSChunkReader for reading
// aws-chunked encoded chunks.
func newBufferedAWSChunkReader(reader io.Reader, chunkSize int) *bufferedAWSChunkReader {
return &bufferedAWSChunkReader{
reader: reader,
chunkSize: chunkSize,
chunkSizeStr: strconv.FormatInt(int64(chunkSize), 16),
headerBuffer: bytes.NewBuffer(make([]byte, 0, 64)),
chunkBuffer: bytes.NewBuffer(make([]byte, 0, chunkSize+len(crlf))),
}
}
// Read attempts to read from the underlying io.Reader writing aws-chunked
// chunk encoded bytes to p. When the underlying io.Reader has been completed
// read the end chunk will be available. Once the end chunk is read, the reader
// will return EOF.
func (r *bufferedAWSChunkReader) Read(p []byte) (n int, err error) {
if r.multiReaderLen == 0 && r.endChunkDone {
return 0, io.EOF
}
if r.multiReader == nil || r.multiReaderLen == 0 {
r.multiReader, r.multiReaderLen, err = r.newMultiReader()
if err != nil {
return 0, err
}
}
n, err = r.multiReader.Read(p)
r.multiReaderLen -= n
if err == io.EOF && !r.endChunkDone {
// Edge case handling when the multi-reader has been completely read,
// and returned an EOF, make sure that EOF only gets returned if the
// end chunk was included in the multi-reader. Otherwise, the next call
// to read will initialize the next chunk's multi-reader.
err = nil
}
return n, err
}
// newMultiReader returns a new io.Reader for wrapping the next chunk. Will
// return an error if the underlying reader can not be read from. Will never
// return io.EOF.
func (r *bufferedAWSChunkReader) newMultiReader() (io.Reader, int, error) {
// io.Copy eats the io.EOF returned by io.LimitReader. Any error that
// occurs here is due to an actual read error.
n, err := io.Copy(r.chunkBuffer, io.LimitReader(r.reader, int64(r.chunkSize)))
if err != nil {
return nil, 0, err
}
if n == 0 {
// Early exit writing out only the end chunk. This does not include
// aws-chunk's final `crlf` so that trailers can still be added by
// upstream reader.
r.headerBuffer.Reset()
r.headerBuffer.WriteString("0")
r.headerBuffer.WriteString(crlf)
r.endChunkDone = true
return r.headerBuffer, r.headerBuffer.Len(), nil
}
r.chunkBuffer.WriteString(crlf)
chunkSizeStr := r.chunkSizeStr
if int(n) != r.chunkSize {
chunkSizeStr = strconv.FormatInt(n, 16)
}
r.headerBuffer.Reset()
r.headerBuffer.WriteString(chunkSizeStr)
r.headerBuffer.WriteString(crlf)
return io.MultiReader(
r.headerBuffer,
r.chunkBuffer,
), r.headerBuffer.Len() + r.chunkBuffer.Len(), nil
}
| 390 |
aws-sdk-go-v2 | aws | Go | //go:build go1.16
// +build go1.16
package checksum
import (
"bytes"
"fmt"
"io"
"io/ioutil"
"strings"
"testing"
"testing/iotest"
"github.com/google/go-cmp/cmp"
)
func TestAWSChunkedEncoding(t *testing.T) {
cases := map[string]struct {
reader *awsChunkedEncoding
expectErr string
expectEncodedLength int64
expectHTTPHeaders map[string][]string
expectPayload []byte
}{
"empty payload fixed stream length": {
reader: newUnsignedAWSChunkedEncoding(strings.NewReader(""),
func(o *awsChunkedEncodingOptions) {
o.StreamLength = 0
}),
expectEncodedLength: 5,
expectHTTPHeaders: map[string][]string{
contentEncodingHeaderName: {
awsChunkedContentEncodingHeaderValue,
},
},
expectPayload: []byte("0\r\n\r\n"),
},
"empty payload unknown stream length": {
reader: newUnsignedAWSChunkedEncoding(strings.NewReader("")),
expectEncodedLength: -1,
expectHTTPHeaders: map[string][]string{
contentEncodingHeaderName: {
awsChunkedContentEncodingHeaderValue,
},
},
expectPayload: []byte("0\r\n\r\n"),
},
"payload fixed stream length": {
reader: newUnsignedAWSChunkedEncoding(strings.NewReader("hello world"),
func(o *awsChunkedEncodingOptions) {
o.StreamLength = 11
}),
expectEncodedLength: 21,
expectHTTPHeaders: map[string][]string{
contentEncodingHeaderName: {
awsChunkedContentEncodingHeaderValue,
},
},
expectPayload: []byte("b\r\nhello world\r\n0\r\n\r\n"),
},
"payload unknown stream length": {
reader: newUnsignedAWSChunkedEncoding(strings.NewReader("hello world")),
expectEncodedLength: -1,
expectHTTPHeaders: map[string][]string{
contentEncodingHeaderName: {
awsChunkedContentEncodingHeaderValue,
},
},
expectPayload: []byte("b\r\nhello world\r\n0\r\n\r\n"),
},
"payload unknown stream length with chunk size": {
reader: newUnsignedAWSChunkedEncoding(strings.NewReader("hello world"),
func(o *awsChunkedEncodingOptions) {
o.ChunkLength = 8
}),
expectEncodedLength: -1,
expectHTTPHeaders: map[string][]string{
contentEncodingHeaderName: {
awsChunkedContentEncodingHeaderValue,
},
},
expectPayload: []byte("8\r\nhello wo\r\n3\r\nrld\r\n0\r\n\r\n"),
},
"payload fixed stream length with chunk size": {
reader: newUnsignedAWSChunkedEncoding(strings.NewReader("hello world"),
func(o *awsChunkedEncodingOptions) {
o.StreamLength = 11
o.ChunkLength = 8
}),
expectEncodedLength: 26,
expectHTTPHeaders: map[string][]string{
contentEncodingHeaderName: {
awsChunkedContentEncodingHeaderValue,
},
},
expectPayload: []byte("8\r\nhello wo\r\n3\r\nrld\r\n0\r\n\r\n"),
},
"payload fixed stream length with fixed length trailer": {
reader: newUnsignedAWSChunkedEncoding(strings.NewReader("hello world"),
func(o *awsChunkedEncodingOptions) {
o.StreamLength = 11
o.Trailers = map[string]awsChunkedTrailerValue{
"foo": {
Get: func() (string, error) {
return "abc123", nil
},
Length: 6,
},
}
}),
expectEncodedLength: 33,
expectHTTPHeaders: map[string][]string{
contentEncodingHeaderName: {
awsChunkedContentEncodingHeaderValue,
},
awsTrailerHeaderName: {"foo"},
},
expectPayload: []byte("b\r\nhello world\r\n0\r\nfoo:abc123\r\n\r\n"),
},
"payload fixed stream length with unknown length trailer": {
reader: newUnsignedAWSChunkedEncoding(strings.NewReader("hello world"),
func(o *awsChunkedEncodingOptions) {
o.StreamLength = 11
o.Trailers = map[string]awsChunkedTrailerValue{
"foo": {
Get: func() (string, error) {
return "abc123", nil
},
Length: -1,
},
}
}),
expectEncodedLength: -1,
expectHTTPHeaders: map[string][]string{
contentEncodingHeaderName: {
awsChunkedContentEncodingHeaderValue,
},
awsTrailerHeaderName: {"foo"},
},
expectPayload: []byte("b\r\nhello world\r\n0\r\nfoo:abc123\r\n\r\n"),
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
if e, a := c.expectEncodedLength, c.reader.EncodedLength(); e != a {
t.Errorf("expect %v encoded length, got %v", e, a)
}
if diff := cmp.Diff(c.expectHTTPHeaders, c.reader.HTTPHeaders()); diff != "" {
t.Errorf("expect HTTP headers match\n%v", diff)
}
actualPayload, err := ioutil.ReadAll(c.reader)
if err == nil && len(c.expectErr) != 0 {
t.Fatalf("expect error %v, got none", c.expectErr)
}
if err != nil && len(c.expectErr) == 0 {
t.Fatalf("expect no error, got %v", err)
}
if err != nil && !strings.Contains(err.Error(), c.expectErr) {
t.Fatalf("expect error to contain %v, got %v", c.expectErr, err)
}
if c.expectErr != "" {
return
}
if diff := cmp.Diff(string(c.expectPayload), string(actualPayload)); diff != "" {
t.Errorf("expect payload match\n%v", diff)
}
})
}
}
func TestUnsignedAWSChunkReader(t *testing.T) {
cases := map[string]struct {
payload interface {
io.Reader
Len() int
}
expectPayload []byte
expectErr string
}{
"empty body": {
payload: bytes.NewReader([]byte{}),
expectPayload: []byte("0\r\n"),
},
"with body": {
payload: strings.NewReader("Hello world"),
expectPayload: []byte("b\r\nHello world\r\n0\r\n"),
},
"large body": {
payload: bytes.NewBufferString("Hello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello world"),
expectPayload: []byte("205\r\nHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello world\r\n0\r\n"),
},
"reader error": {
payload: newLimitReadLener(iotest.ErrReader(fmt.Errorf("some read error")), 128),
expectErr: "some read error",
},
"unknown length reader": {
payload: newUnknownLenReader(io.LimitReader(byteReader('a'), defaultChunkLength*2)),
expectPayload: func() []byte {
reader := newBufferedAWSChunkReader(
io.LimitReader(byteReader('a'), defaultChunkLength*2),
defaultChunkLength,
)
actualPayload, err := ioutil.ReadAll(reader)
if err != nil {
t.Fatalf("failed to create unknown length reader test data, %v", err)
}
return actualPayload
}(),
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
reader := newUnsignedChunkReader(c.payload, int64(c.payload.Len()))
actualPayload, err := ioutil.ReadAll(reader)
if err == nil && len(c.expectErr) != 0 {
t.Fatalf("expect error %v, got none", c.expectErr)
}
if err != nil && len(c.expectErr) == 0 {
t.Fatalf("expect no error, got %v", err)
}
if err != nil && !strings.Contains(err.Error(), c.expectErr) {
t.Fatalf("expect error to contain %v, got %v", c.expectErr, err)
}
if c.expectErr != "" {
return
}
if diff := cmp.Diff(string(c.expectPayload), string(actualPayload)); diff != "" {
t.Errorf("expect payload match\n%v", diff)
}
})
}
}
func TestBufferedAWSChunkReader(t *testing.T) {
cases := map[string]struct {
payload io.Reader
readSize int
chunkSize int
expectPayload []byte
expectErr string
}{
"empty body": {
payload: bytes.NewReader([]byte{}),
chunkSize: 4,
expectPayload: []byte("0\r\n"),
},
"with one chunk body": {
payload: strings.NewReader("Hello world"),
chunkSize: 20,
expectPayload: []byte("b\r\nHello world\r\n0\r\n"),
},
"single byte read": {
payload: strings.NewReader("Hello world"),
chunkSize: 8,
readSize: 1,
expectPayload: []byte("8\r\nHello wo\r\n3\r\nrld\r\n0\r\n"),
},
"single chunk and byte read": {
payload: strings.NewReader("Hello world"),
chunkSize: 1,
readSize: 1,
expectPayload: []byte("1\r\nH\r\n1\r\ne\r\n1\r\nl\r\n1\r\nl\r\n1\r\no\r\n1\r\n \r\n1\r\nw\r\n1\r\no\r\n1\r\nr\r\n1\r\nl\r\n1\r\nd\r\n0\r\n"),
},
"with two chunk body": {
payload: strings.NewReader("Hello world"),
chunkSize: 8,
expectPayload: []byte("8\r\nHello wo\r\n3\r\nrld\r\n0\r\n"),
},
"chunk size equal to read size": {
payload: strings.NewReader("Hello world"),
chunkSize: 512,
expectPayload: []byte("b\r\nHello world\r\n0\r\n"),
},
"chunk size greater than read size": {
payload: strings.NewReader("Hello world"),
chunkSize: 1024,
expectPayload: []byte("b\r\nHello world\r\n0\r\n"),
},
"payload size more than default read size, chunk size less than read size": {
payload: bytes.NewBufferString("Hello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello world"),
chunkSize: 500,
expectPayload: []byte("1f4\r\nHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello\r\n11\r\n worldHello world\r\n0\r\n"),
},
"payload size more than default read size, chunk size equal to read size": {
payload: bytes.NewBufferString("Hello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello world"),
chunkSize: 512,
expectPayload: []byte("200\r\nHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello \r\n5\r\nworld\r\n0\r\n"),
},
"payload size more than default read size, chunk size more than read size": {
payload: bytes.NewBufferString("Hello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello world"),
chunkSize: 1024,
expectPayload: []byte("205\r\nHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello worldHello " +
"worldHello worldHello worldHello worldHello worldHello world\r\n0\r\n"),
},
"reader error": {
payload: iotest.ErrReader(fmt.Errorf("some read error")),
chunkSize: 128,
expectErr: "some read error",
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
reader := newBufferedAWSChunkReader(c.payload, c.chunkSize)
var actualPayload []byte
var err error
if c.readSize != 0 {
for err == nil {
var n int
p := make([]byte, c.readSize)
n, err = reader.Read(p)
if n != 0 {
actualPayload = append(actualPayload, p[:n]...)
}
}
if err == io.EOF {
err = nil
}
} else {
actualPayload, err = ioutil.ReadAll(reader)
}
if err == nil && len(c.expectErr) != 0 {
t.Fatalf("expect error %v, got none", c.expectErr)
}
if err != nil && len(c.expectErr) == 0 {
t.Fatalf("expect no error, got %v", err)
}
if err != nil && !strings.Contains(err.Error(), c.expectErr) {
t.Fatalf("expect error to contain %v, got %v", c.expectErr, err)
}
if c.expectErr != "" {
return
}
if diff := cmp.Diff(string(c.expectPayload), string(actualPayload)); diff != "" {
t.Errorf("expect payload match\n%v", diff)
}
})
}
}
func TestAwsChunkedTrailerReader(t *testing.T) {
cases := map[string]struct {
reader *awsChunkedTrailerReader
expectErr string
expectEncodedLength int
expectPayload []byte
}{
"no trailers": {
reader: newAWSChunkedTrailerReader(nil),
expectPayload: []byte{},
},
"unknown length trailers": {
reader: newAWSChunkedTrailerReader(map[string]awsChunkedTrailerValue{
"foo": {
Get: func() (string, error) {
return "abc123", nil
},
Length: -1,
},
}),
expectEncodedLength: -1,
expectPayload: []byte("foo:abc123\r\n"),
},
"known length trailers": {
reader: newAWSChunkedTrailerReader(map[string]awsChunkedTrailerValue{
"foo": {
Get: func() (string, error) {
return "abc123", nil
},
Length: 6,
},
}),
expectEncodedLength: 12,
expectPayload: []byte("foo:abc123\r\n"),
},
"trailer error": {
reader: newAWSChunkedTrailerReader(map[string]awsChunkedTrailerValue{
"foo": {
Get: func() (string, error) {
return "", fmt.Errorf("some error")
},
Length: 6,
},
}),
expectEncodedLength: 12,
expectErr: "failed to get trailer",
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
if e, a := c.expectEncodedLength, c.reader.EncodedLength(); e != a {
t.Errorf("expect %v encoded length, got %v", e, a)
}
actualPayload, err := ioutil.ReadAll(c.reader)
// Asserts
if err == nil && len(c.expectErr) != 0 {
t.Fatalf("expect error %v, got none", c.expectErr)
}
if err != nil && len(c.expectErr) == 0 {
t.Fatalf("expect no error, got %v", err)
}
if err != nil && !strings.Contains(err.Error(), c.expectErr) {
t.Fatalf("expect error to contain %v, got %v", c.expectErr, err)
}
if c.expectErr != "" {
return
}
if diff := cmp.Diff(string(c.expectPayload), string(actualPayload)); diff != "" {
t.Errorf("expect payload match\n%v", diff)
}
})
}
}
type limitReadLener struct {
io.Reader
length int
}
func newLimitReadLener(r io.Reader, l int) *limitReadLener {
return &limitReadLener{
Reader: io.LimitReader(r, int64(l)),
length: l,
}
}
func (r *limitReadLener) Len() int {
return r.length
}
type unknownLenReader struct {
io.Reader
}
func newUnknownLenReader(r io.Reader) *unknownLenReader {
return &unknownLenReader{
Reader: r,
}
}
func (r *unknownLenReader) Len() int {
return -1
}
type byteReader byte
func (r byteReader) Read(p []byte) (int, error) {
for i := 0; i < len(p); i++ {
p[i] = byte(r)
}
return len(p), nil
}
| 508 |
aws-sdk-go-v2 | aws | Go | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT.
package checksum
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.1.29"
| 7 |
aws-sdk-go-v2 | aws | Go | package checksum
import (
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// InputMiddlewareOptions provides the options for the request
// checksum middleware setup.
type InputMiddlewareOptions struct {
// GetAlgorithm is a function to get the checksum algorithm of the
// input payload from the input parameters.
//
// Given the input parameter value, the function must return the algorithm
// and true, or false if no algorithm is specified.
GetAlgorithm func(interface{}) (string, bool)
// Forces the middleware to compute the input payload's checksum. The
// request will fail if the algorithm is not specified or unable to compute
// the checksum.
RequireChecksum bool
// Enables support for wrapping the serialized input payload with a
// content-encoding: aws-check wrapper, and including a trailer for the
// algorithm's checksum value.
//
// The checksum will not be computed, nor added as trailing checksum, if
// the Algorithm's header is already set on the request.
EnableTrailingChecksum bool
// Enables support for computing the SHA256 checksum of input payloads
// along with the algorithm specified checksum. Prevents downstream
// middleware handlers (computePayloadSHA256) re-reading the payload.
//
// The SHA256 payload checksum will only be used for computed for requests
// that are not TLS, or do not enable trailing checksums.
//
// The SHA256 payload hash will not be computed, if the Algorithm's header
// is already set on the request.
EnableComputeSHA256PayloadHash bool
// Enables support for setting the aws-chunked decoded content length
// header for the decoded length of the underlying stream. Will only be set
// when used with trailing checksums, and aws-chunked content-encoding.
EnableDecodedContentLengthHeader bool
}
// AddInputMiddleware adds the middleware for performing checksum computing
// of request payloads, and checksum validation of response payloads.
func AddInputMiddleware(stack *middleware.Stack, options InputMiddlewareOptions) (err error) {
// TODO ensure this works correctly with presigned URLs
// Middleware stack:
// * (OK)(Initialize) --none--
// * (OK)(Serialize) EndpointResolver
// * (OK)(Build) ComputeContentLength
// * (AD)(Build) Header ComputeInputPayloadChecksum
// * SIGNED Payload - If HTTP && not support trailing checksum
// * UNSIGNED Payload - If HTTPS && not support trailing checksum
// * (RM)(Build) ContentChecksum - OK to remove
// * (OK)(Build) ComputePayloadHash
// * v4.dynamicPayloadSigningMiddleware
// * v4.computePayloadSHA256
// * v4.unsignedPayload
// (OK)(Build) Set computedPayloadHash header
// * (OK)(Finalize) Retry
// * (AD)(Finalize) Trailer ComputeInputPayloadChecksum,
// * Requires HTTPS && support trailing checksum
// * UNSIGNED Payload
// * Finalize run if HTTPS && support trailing checksum
// * (OK)(Finalize) Signing
// * (OK)(Deserialize) --none--
// Initial checksum configuration look up middleware
err = stack.Initialize.Add(&setupInputContext{
GetAlgorithm: options.GetAlgorithm,
}, middleware.Before)
if err != nil {
return err
}
stack.Build.Remove("ContentChecksum")
// Create the compute checksum middleware that will be added as both a
// build and finalize handler.
inputChecksum := &computeInputPayloadChecksum{
RequireChecksum: options.RequireChecksum,
EnableTrailingChecksum: options.EnableTrailingChecksum,
EnableComputePayloadHash: options.EnableComputeSHA256PayloadHash,
EnableDecodedContentLengthHeader: options.EnableDecodedContentLengthHeader,
}
// Insert header checksum after ComputeContentLength middleware, must also
// be before the computePayloadHash middleware handlers.
err = stack.Build.Insert(inputChecksum,
(*smithyhttp.ComputeContentLength)(nil).ID(),
middleware.After)
if err != nil {
return err
}
// If trailing checksum is not supported no need for finalize handler to be added.
if options.EnableTrailingChecksum {
err = stack.Finalize.Insert(inputChecksum, "Retry", middleware.After)
if err != nil {
return err
}
}
return nil
}
// RemoveInputMiddleware Removes the compute input payload checksum middleware
// handlers from the stack.
func RemoveInputMiddleware(stack *middleware.Stack) {
id := (*setupInputContext)(nil).ID()
stack.Initialize.Remove(id)
id = (*computeInputPayloadChecksum)(nil).ID()
stack.Build.Remove(id)
stack.Finalize.Remove(id)
}
// OutputMiddlewareOptions provides options for configuring output checksum
// validation middleware.
type OutputMiddlewareOptions struct {
// GetValidationMode is a function to get the checksum validation
// mode of the output payload from the input parameters.
//
// Given the input parameter value, the function must return the validation
// mode and true, or false if no mode is specified.
GetValidationMode func(interface{}) (string, bool)
// The set of checksum algorithms that should be used for response payload
// checksum validation. The algorithm(s) used will be a union of the
// output's returned algorithms and this set.
//
// Only the first algorithm in the union is currently used.
ValidationAlgorithms []string
// If set the middleware will ignore output multipart checksums. Otherwise
// an checksum format error will be returned by the middleware.
IgnoreMultipartValidation bool
// When set the middleware will log when output does not have checksum or
// algorithm to validate.
LogValidationSkipped bool
// When set the middleware will log when the output contains a multipart
// checksum that was, skipped and not validated.
LogMultipartValidationSkipped bool
}
// AddOutputMiddleware adds the middleware for validating response payload's
// checksum.
func AddOutputMiddleware(stack *middleware.Stack, options OutputMiddlewareOptions) error {
err := stack.Initialize.Add(&setupOutputContext{
GetValidationMode: options.GetValidationMode,
}, middleware.Before)
if err != nil {
return err
}
// Resolve a supported priority order list of algorithms to validate.
algorithms := FilterSupportedAlgorithms(options.ValidationAlgorithms)
m := &validateOutputPayloadChecksum{
Algorithms: algorithms,
IgnoreMultipartValidation: options.IgnoreMultipartValidation,
LogMultipartValidationSkipped: options.LogMultipartValidationSkipped,
LogValidationSkipped: options.LogValidationSkipped,
}
return stack.Deserialize.Add(m, middleware.After)
}
// RemoveOutputMiddleware Removes the compute input payload checksum middleware
// handlers from the stack.
func RemoveOutputMiddleware(stack *middleware.Stack) {
id := (*setupOutputContext)(nil).ID()
stack.Initialize.Remove(id)
id = (*validateOutputPayloadChecksum)(nil).ID()
stack.Deserialize.Remove(id)
}
| 186 |
aws-sdk-go-v2 | aws | Go | //go:build go1.16
// +build go1.16
package checksum
import (
"context"
"testing"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"github.com/google/go-cmp/cmp"
)
func TestAddInputMiddleware(t *testing.T) {
cases := map[string]struct {
options InputMiddlewareOptions
expectErr string
expectMiddleware []string
expectInitialize *setupInputContext
expectBuild *computeInputPayloadChecksum
expectFinalize *computeInputPayloadChecksum
}{
"with trailing checksum": {
options: InputMiddlewareOptions{
GetAlgorithm: func(interface{}) (string, bool) {
return string(AlgorithmCRC32), true
},
EnableTrailingChecksum: true,
EnableComputeSHA256PayloadHash: true,
EnableDecodedContentLengthHeader: true,
},
expectMiddleware: []string{
"test",
"Initialize stack step",
"AWSChecksum:SetupInputContext",
"Serialize stack step",
"Build stack step",
"ComputeContentLength",
"AWSChecksum:ComputeInputPayloadChecksum",
"ComputePayloadHash",
"Finalize stack step",
"Retry",
"AWSChecksum:ComputeInputPayloadChecksum",
"Signing",
"Deserialize stack step",
},
expectInitialize: &setupInputContext{
GetAlgorithm: func(interface{}) (string, bool) {
return string(AlgorithmCRC32), true
},
},
expectBuild: &computeInputPayloadChecksum{
EnableTrailingChecksum: true,
EnableComputePayloadHash: true,
EnableDecodedContentLengthHeader: true,
},
},
"with checksum required": {
options: InputMiddlewareOptions{
GetAlgorithm: func(interface{}) (string, bool) {
return string(AlgorithmCRC32), true
},
EnableTrailingChecksum: true,
RequireChecksum: true,
},
expectMiddleware: []string{
"test",
"Initialize stack step",
"AWSChecksum:SetupInputContext",
"Serialize stack step",
"Build stack step",
"ComputeContentLength",
"AWSChecksum:ComputeInputPayloadChecksum",
"ComputePayloadHash",
"Finalize stack step",
"Retry",
"AWSChecksum:ComputeInputPayloadChecksum",
"Signing",
"Deserialize stack step",
},
expectInitialize: &setupInputContext{
GetAlgorithm: func(interface{}) (string, bool) {
return string(AlgorithmCRC32), true
},
},
expectBuild: &computeInputPayloadChecksum{
RequireChecksum: true,
EnableTrailingChecksum: true,
},
},
"no trailing checksum": {
options: InputMiddlewareOptions{
GetAlgorithm: func(interface{}) (string, bool) {
return string(AlgorithmCRC32), true
},
},
expectMiddleware: []string{
"test",
"Initialize stack step",
"AWSChecksum:SetupInputContext",
"Serialize stack step",
"Build stack step",
"ComputeContentLength",
"AWSChecksum:ComputeInputPayloadChecksum",
"ComputePayloadHash",
"Finalize stack step",
"Retry",
"Signing",
"Deserialize stack step",
},
expectInitialize: &setupInputContext{
GetAlgorithm: func(interface{}) (string, bool) {
return string(AlgorithmCRC32), true
},
},
expectBuild: &computeInputPayloadChecksum{},
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
stack := middleware.NewStack("test", smithyhttp.NewStackRequest)
stack.Build.Add(nopBuildMiddleware("ComputeContentLength"), middleware.After)
stack.Build.Add(nopBuildMiddleware("ContentChecksum"), middleware.After)
stack.Build.Add(nopBuildMiddleware("ComputePayloadHash"), middleware.After)
stack.Finalize.Add(nopFinalizeMiddleware("Retry"), middleware.After)
stack.Finalize.Add(nopFinalizeMiddleware("Signing"), middleware.After)
err := AddInputMiddleware(stack, c.options)
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
if diff := cmp.Diff(c.expectMiddleware, stack.List()); diff != "" {
t.Fatalf("expect stack list match:\n%s", diff)
}
initializeMiddleware, ok := stack.Initialize.Get((*setupInputContext)(nil).ID())
if e, a := (c.expectInitialize != nil), ok; e != a {
t.Errorf("expect initialize middleware %t, got %t", e, a)
}
if c.expectInitialize != nil && ok {
setupInput := initializeMiddleware.(*setupInputContext)
if e, a := c.options.GetAlgorithm != nil, setupInput.GetAlgorithm != nil; e != a {
t.Fatalf("expect GetAlgorithm %t, got %t", e, a)
}
expectAlgo, expectOK := c.options.GetAlgorithm(nil)
actualAlgo, actualOK := setupInput.GetAlgorithm(nil)
if e, a := expectAlgo, actualAlgo; e != a {
t.Errorf("expect %v algorithm, got %v", e, a)
}
if e, a := expectOK, actualOK; e != a {
t.Errorf("expect %v algorithm present, got %v", e, a)
}
}
buildMiddleware, ok := stack.Build.Get((*computeInputPayloadChecksum)(nil).ID())
if e, a := (c.expectBuild != nil), ok; e != a {
t.Errorf("expect build middleware %t, got %t", e, a)
}
var computeInput *computeInputPayloadChecksum
if c.expectBuild != nil && ok {
computeInput = buildMiddleware.(*computeInputPayloadChecksum)
if e, a := c.expectBuild.RequireChecksum, computeInput.RequireChecksum; e != a {
t.Errorf("expect %v require checksum, got %v", e, a)
}
if e, a := c.expectBuild.EnableTrailingChecksum, computeInput.EnableTrailingChecksum; e != a {
t.Errorf("expect %v enable trailing checksum, got %v", e, a)
}
if e, a := c.expectBuild.EnableComputePayloadHash, computeInput.EnableComputePayloadHash; e != a {
t.Errorf("expect %v enable compute payload hash, got %v", e, a)
}
if e, a := c.expectBuild.EnableDecodedContentLengthHeader, computeInput.EnableDecodedContentLengthHeader; e != a {
t.Errorf("expect %v enable decoded length header, got %v", e, a)
}
}
if c.expectFinalize != nil && ok {
finalizeMiddleware, ok := stack.Build.Get((*computeInputPayloadChecksum)(nil).ID())
if !ok {
t.Errorf("expect finalize middleware")
}
finalizeComputeInput := finalizeMiddleware.(*computeInputPayloadChecksum)
if e, a := computeInput, finalizeComputeInput; e != a {
t.Errorf("expect build and finalize to be same value")
}
}
})
}
}
func TestRemoveInputMiddleware(t *testing.T) {
stack := middleware.NewStack("test", smithyhttp.NewStackRequest)
stack.Build.Add(nopBuildMiddleware("ComputeContentLength"), middleware.After)
stack.Build.Add(nopBuildMiddleware("ContentChecksum"), middleware.After)
stack.Build.Add(nopBuildMiddleware("ComputePayloadHash"), middleware.After)
stack.Finalize.Add(nopFinalizeMiddleware("Retry"), middleware.After)
stack.Finalize.Add(nopFinalizeMiddleware("Signing"), middleware.After)
err := AddInputMiddleware(stack, InputMiddlewareOptions{
EnableTrailingChecksum: true,
})
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
RemoveInputMiddleware(stack)
expectStack := []string{
"test",
"Initialize stack step",
"Serialize stack step",
"Build stack step",
"ComputeContentLength",
"ComputePayloadHash",
"Finalize stack step",
"Retry",
"Signing",
"Deserialize stack step",
}
if diff := cmp.Diff(expectStack, stack.List()); diff != "" {
t.Fatalf("expect stack list match:\n%s", diff)
}
}
func TestAddOutputMiddleware(t *testing.T) {
cases := map[string]struct {
options OutputMiddlewareOptions
expectErr string
expectMiddleware []string
expectInitialize *setupOutputContext
expectDeserialize *validateOutputPayloadChecksum
}{
"validate output": {
options: OutputMiddlewareOptions{
GetValidationMode: func(interface{}) (string, bool) {
return "ENABLED", true
},
ValidationAlgorithms: []string{
"crc32", "sha1", "abc123", "crc32c",
},
IgnoreMultipartValidation: true,
LogMultipartValidationSkipped: true,
LogValidationSkipped: true,
},
expectMiddleware: []string{
"test",
"Initialize stack step",
"AWSChecksum:SetupOutputContext",
"Serialize stack step",
"Build stack step",
"Finalize stack step",
"Deserialize stack step",
"AWSChecksum:ValidateOutputPayloadChecksum",
},
expectInitialize: &setupOutputContext{
GetValidationMode: func(interface{}) (string, bool) {
return "ENABLED", true
},
},
expectDeserialize: &validateOutputPayloadChecksum{
Algorithms: []Algorithm{
AlgorithmCRC32, AlgorithmSHA1, AlgorithmCRC32C,
},
IgnoreMultipartValidation: true,
LogMultipartValidationSkipped: true,
LogValidationSkipped: true,
},
},
"validate options off": {
options: OutputMiddlewareOptions{
GetValidationMode: func(interface{}) (string, bool) {
return "ENABLED", true
},
ValidationAlgorithms: []string{
"crc32", "sha1", "abc123", "crc32c",
},
},
expectMiddleware: []string{
"test",
"Initialize stack step",
"AWSChecksum:SetupOutputContext",
"Serialize stack step",
"Build stack step",
"Finalize stack step",
"Deserialize stack step",
"AWSChecksum:ValidateOutputPayloadChecksum",
},
expectInitialize: &setupOutputContext{
GetValidationMode: func(interface{}) (string, bool) {
return "ENABLED", true
},
},
expectDeserialize: &validateOutputPayloadChecksum{
Algorithms: []Algorithm{
AlgorithmCRC32, AlgorithmSHA1, AlgorithmCRC32C,
},
},
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
stack := middleware.NewStack("test", smithyhttp.NewStackRequest)
err := AddOutputMiddleware(stack, c.options)
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
if diff := cmp.Diff(c.expectMiddleware, stack.List()); diff != "" {
t.Fatalf("expect stack list match:\n%s", diff)
}
initializeMiddleware, ok := stack.Initialize.Get((*setupOutputContext)(nil).ID())
if e, a := (c.expectInitialize != nil), ok; e != a {
t.Errorf("expect initialize middleware %t, got %t", e, a)
}
if c.expectInitialize != nil && ok {
setupOutput := initializeMiddleware.(*setupOutputContext)
if e, a := c.options.GetValidationMode != nil, setupOutput.GetValidationMode != nil; e != a {
t.Fatalf("expect GetValidationMode %t, got %t", e, a)
}
expectMode, expectOK := c.options.GetValidationMode(nil)
actualMode, actualOK := setupOutput.GetValidationMode(nil)
if e, a := expectMode, actualMode; e != a {
t.Errorf("expect %v mode, got %v", e, a)
}
if e, a := expectOK, actualOK; e != a {
t.Errorf("expect %v mode present, got %v", e, a)
}
}
deserializeMiddleware, ok := stack.Deserialize.Get((*validateOutputPayloadChecksum)(nil).ID())
if e, a := (c.expectDeserialize != nil), ok; e != a {
t.Errorf("expect deserialize middleware %t, got %t", e, a)
}
if c.expectDeserialize != nil && ok {
validateOutput := deserializeMiddleware.(*validateOutputPayloadChecksum)
if diff := cmp.Diff(c.expectDeserialize.Algorithms, validateOutput.Algorithms); diff != "" {
t.Errorf("expect algorithms match:\n%s", diff)
}
if e, a := c.expectDeserialize.IgnoreMultipartValidation, validateOutput.IgnoreMultipartValidation; e != a {
t.Errorf("expect %v ignore multipart checksum, got %v", e, a)
}
if e, a := c.expectDeserialize.LogMultipartValidationSkipped, validateOutput.LogMultipartValidationSkipped; e != a {
t.Errorf("expect %v log multipart skipped, got %v", e, a)
}
if e, a := c.expectDeserialize.LogValidationSkipped, validateOutput.LogValidationSkipped; e != a {
t.Errorf("expect %v log validation skipped, got %v", e, a)
}
}
})
}
}
func TestRemoveOutputMiddleware(t *testing.T) {
stack := middleware.NewStack("test", smithyhttp.NewStackRequest)
err := AddOutputMiddleware(stack, OutputMiddlewareOptions{})
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
RemoveOutputMiddleware(stack)
expectStack := []string{
"test",
"Initialize stack step",
"Serialize stack step",
"Build stack step",
"Finalize stack step",
"Deserialize stack step",
}
if diff := cmp.Diff(expectStack, stack.List()); diff != "" {
t.Fatalf("expect stack list match:\n%s", diff)
}
}
func setSerializedRequest(req *smithyhttp.Request) middleware.SerializeMiddleware {
return middleware.SerializeMiddlewareFunc("OperationSerializer",
func(ctx context.Context, input middleware.SerializeInput, next middleware.SerializeHandler) (
middleware.SerializeOutput, middleware.Metadata, error,
) {
input.Request = req
return next.HandleSerialize(ctx, input)
})
}
func nopBuildMiddleware(id string) middleware.BuildMiddleware {
return middleware.BuildMiddlewareFunc(id,
func(ctx context.Context, input middleware.BuildInput, next middleware.BuildHandler) (
middleware.BuildOutput, middleware.Metadata, error,
) {
return next.HandleBuild(ctx, input)
})
}
func nopFinalizeMiddleware(id string) middleware.FinalizeMiddleware {
return middleware.FinalizeMiddlewareFunc(id,
func(ctx context.Context, input middleware.FinalizeInput, next middleware.FinalizeHandler) (
middleware.FinalizeOutput, middleware.Metadata, error,
) {
return next.HandleFinalize(ctx, input)
})
}
| 413 |
aws-sdk-go-v2 | aws | Go | package checksum
import (
"context"
"crypto/sha256"
"fmt"
"hash"
"io"
"strconv"
v4 "github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
const (
contentMD5Header = "Content-Md5"
streamingUnsignedPayloadTrailerPayloadHash = "STREAMING-UNSIGNED-PAYLOAD-TRAILER"
)
// computedInputChecksumsKey is the metadata key for recording the algorithm the
// checksum was computed for and the checksum value.
type computedInputChecksumsKey struct{}
// GetComputedInputChecksums returns the map of checksum algorithm to their
// computed value stored in the middleware Metadata. Returns false if no values
// were stored in the Metadata.
func GetComputedInputChecksums(m middleware.Metadata) (map[string]string, bool) {
vs, ok := m.Get(computedInputChecksumsKey{}).(map[string]string)
return vs, ok
}
// SetComputedInputChecksums stores the map of checksum algorithm to their
// computed value in the middleware Metadata. Overwrites any values that
// currently exist in the metadata.
func SetComputedInputChecksums(m *middleware.Metadata, vs map[string]string) {
m.Set(computedInputChecksumsKey{}, vs)
}
// computeInputPayloadChecksum middleware computes payload checksum
type computeInputPayloadChecksum struct {
// Enables support for wrapping the serialized input payload with a
// content-encoding: aws-check wrapper, and including a trailer for the
// algorithm's checksum value.
//
// The checksum will not be computed, nor added as trailing checksum, if
// the Algorithm's header is already set on the request.
EnableTrailingChecksum bool
// States that a checksum is required to be included for the operation. If
// Input does not specify a checksum, fallback to built in MD5 checksum is
// used.
//
// Replaces smithy-go's ContentChecksum middleware.
RequireChecksum bool
// Enables support for computing the SHA256 checksum of input payloads
// along with the algorithm specified checksum. Prevents downstream
// middleware handlers (computePayloadSHA256) re-reading the payload.
//
// The SHA256 payload hash will only be used for computed for requests
// that are not TLS, or do not enable trailing checksums.
//
// The SHA256 payload hash will not be computed, if the Algorithm's header
// is already set on the request.
EnableComputePayloadHash bool
// Enables support for setting the aws-chunked decoded content length
// header for the decoded length of the underlying stream. Will only be set
// when used with trailing checksums, and aws-chunked content-encoding.
EnableDecodedContentLengthHeader bool
buildHandlerRun bool
deferToFinalizeHandler bool
}
// ID provides the middleware's identifier.
func (m *computeInputPayloadChecksum) ID() string {
return "AWSChecksum:ComputeInputPayloadChecksum"
}
type computeInputHeaderChecksumError struct {
Msg string
Err error
}
func (e computeInputHeaderChecksumError) Error() string {
const intro = "compute input header checksum failed"
if e.Err != nil {
return fmt.Sprintf("%s, %s, %v", intro, e.Msg, e.Err)
}
return fmt.Sprintf("%s, %s", intro, e.Msg)
}
func (e computeInputHeaderChecksumError) Unwrap() error { return e.Err }
// HandleBuild handles computing the payload's checksum, in the following cases:
// - Is HTTP, not HTTPS
// - RequireChecksum is true, and no checksums were specified via the Input
// - Trailing checksums are not supported
//
// The build handler must be inserted in the stack before ContentPayloadHash
// and after ComputeContentLength.
func (m *computeInputPayloadChecksum) HandleBuild(
ctx context.Context, in middleware.BuildInput, next middleware.BuildHandler,
) (
out middleware.BuildOutput, metadata middleware.Metadata, err error,
) {
m.buildHandlerRun = true
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, computeInputHeaderChecksumError{
Msg: fmt.Sprintf("unknown request type %T", req),
}
}
var algorithm Algorithm
var checksum string
defer func() {
if algorithm == "" || checksum == "" || err != nil {
return
}
// Record the checksum and algorithm that was computed
SetComputedInputChecksums(&metadata, map[string]string{
string(algorithm): checksum,
})
}()
// If no algorithm was specified, and the operation requires a checksum,
// fallback to the legacy content MD5 checksum.
algorithm, ok, err = getInputAlgorithm(ctx)
if err != nil {
return out, metadata, err
} else if !ok {
if m.RequireChecksum {
checksum, err = setMD5Checksum(ctx, req)
if err != nil {
return out, metadata, computeInputHeaderChecksumError{
Msg: "failed to compute stream's MD5 checksum",
Err: err,
}
}
algorithm = Algorithm("MD5")
}
return next.HandleBuild(ctx, in)
}
// If the checksum header is already set nothing to do.
checksumHeader := AlgorithmHTTPHeader(algorithm)
if checksum = req.Header.Get(checksumHeader); checksum != "" {
return next.HandleBuild(ctx, in)
}
computePayloadHash := m.EnableComputePayloadHash
if v := v4.GetPayloadHash(ctx); v != "" {
computePayloadHash = false
}
stream := req.GetStream()
streamLength, err := getRequestStreamLength(req)
if err != nil {
return out, metadata, computeInputHeaderChecksumError{
Msg: "failed to determine stream length",
Err: err,
}
}
// If trailing checksums are supported, the request is HTTPS, and the
// stream is not nil or empty, there is nothing to do in the build stage.
// The checksum will be added to the request as a trailing checksum in the
// finalize handler.
//
// Nil and empty streams will always be handled as a request header,
// regardless if the operation supports trailing checksums or not.
if req.IsHTTPS() {
if stream != nil && streamLength != 0 && m.EnableTrailingChecksum {
if m.EnableComputePayloadHash {
// payload hash is set as header in Build middleware handler,
// ContentSHA256Header.
ctx = v4.SetPayloadHash(ctx, streamingUnsignedPayloadTrailerPayloadHash)
}
m.deferToFinalizeHandler = true
return next.HandleBuild(ctx, in)
}
// If trailing checksums are not enabled but protocol is still HTTPS
// disabling computing the payload hash. Downstream middleware handler
// (ComputetPayloadHash) will set the payload hash to unsigned payload,
// if signing was used.
computePayloadHash = false
}
// Only seekable streams are supported for non-trailing checksums, because
// the stream needs to be rewound before the handler can continue.
if stream != nil && !req.IsStreamSeekable() {
return out, metadata, computeInputHeaderChecksumError{
Msg: "unseekable stream is not supported without TLS and trailing checksum",
}
}
var sha256Checksum string
checksum, sha256Checksum, err = computeStreamChecksum(
algorithm, stream, computePayloadHash)
if err != nil {
return out, metadata, computeInputHeaderChecksumError{
Msg: "failed to compute stream checksum",
Err: err,
}
}
if err := req.RewindStream(); err != nil {
return out, metadata, computeInputHeaderChecksumError{
Msg: "failed to rewind stream",
Err: err,
}
}
req.Header.Set(checksumHeader, checksum)
if computePayloadHash {
ctx = v4.SetPayloadHash(ctx, sha256Checksum)
}
return next.HandleBuild(ctx, in)
}
type computeInputTrailingChecksumError struct {
Msg string
Err error
}
func (e computeInputTrailingChecksumError) Error() string {
const intro = "compute input trailing checksum failed"
if e.Err != nil {
return fmt.Sprintf("%s, %s, %v", intro, e.Msg, e.Err)
}
return fmt.Sprintf("%s, %s", intro, e.Msg)
}
func (e computeInputTrailingChecksumError) Unwrap() error { return e.Err }
// HandleFinalize handles computing the payload's checksum, in the following cases:
// - Is HTTPS, not HTTP
// - A checksum was specified via the Input
// - Trailing checksums are supported.
//
// The finalize handler must be inserted in the stack before Signing, and after Retry.
func (m *computeInputPayloadChecksum) HandleFinalize(
ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler,
) (
out middleware.FinalizeOutput, metadata middleware.Metadata, err error,
) {
if !m.deferToFinalizeHandler {
if !m.buildHandlerRun {
return out, metadata, computeInputTrailingChecksumError{
Msg: "build handler was removed without also removing finalize handler",
}
}
return next.HandleFinalize(ctx, in)
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, computeInputTrailingChecksumError{
Msg: fmt.Sprintf("unknown request type %T", req),
}
}
// Trailing checksums are only supported when TLS is enabled.
if !req.IsHTTPS() {
return out, metadata, computeInputTrailingChecksumError{
Msg: "HTTPS required",
}
}
// If no algorithm was specified, there is nothing to do.
algorithm, ok, err := getInputAlgorithm(ctx)
if err != nil {
return out, metadata, computeInputTrailingChecksumError{
Msg: "failed to get algorithm",
Err: err,
}
} else if !ok {
return out, metadata, computeInputTrailingChecksumError{
Msg: "no algorithm specified",
}
}
// If the checksum header is already set before finalize could run, there
// is nothing to do.
checksumHeader := AlgorithmHTTPHeader(algorithm)
if req.Header.Get(checksumHeader) != "" {
return next.HandleFinalize(ctx, in)
}
stream := req.GetStream()
streamLength, err := getRequestStreamLength(req)
if err != nil {
return out, metadata, computeInputTrailingChecksumError{
Msg: "failed to determine stream length",
Err: err,
}
}
if stream == nil || streamLength == 0 {
// Nil and empty streams are handled by the Build handler. They are not
// supported by the trailing checksums finalize handler. There is no
// benefit to sending them as trailers compared to headers.
return out, metadata, computeInputTrailingChecksumError{
Msg: "nil or empty streams are not supported",
}
}
checksumReader, err := newComputeChecksumReader(stream, algorithm)
if err != nil {
return out, metadata, computeInputTrailingChecksumError{
Msg: "failed to created checksum reader",
Err: err,
}
}
awsChunkedReader := newUnsignedAWSChunkedEncoding(checksumReader,
func(o *awsChunkedEncodingOptions) {
o.Trailers[AlgorithmHTTPHeader(checksumReader.Algorithm())] = awsChunkedTrailerValue{
Get: checksumReader.Base64Checksum,
Length: checksumReader.Base64ChecksumLength(),
}
o.StreamLength = streamLength
})
for key, values := range awsChunkedReader.HTTPHeaders() {
for _, value := range values {
req.Header.Add(key, value)
}
}
// Setting the stream on the request will create a copy. The content length
// is not updated until after the request is copied to prevent impacting
// upstream middleware.
req, err = req.SetStream(awsChunkedReader)
if err != nil {
return out, metadata, computeInputTrailingChecksumError{
Msg: "failed updating request to trailing checksum wrapped stream",
Err: err,
}
}
req.ContentLength = awsChunkedReader.EncodedLength()
in.Request = req
// Add decoded content length header if original stream's content length is known.
if streamLength != -1 && m.EnableDecodedContentLengthHeader {
req.Header.Set(decodedContentLengthHeaderName, strconv.FormatInt(streamLength, 10))
}
out, metadata, err = next.HandleFinalize(ctx, in)
if err == nil {
checksum, err := checksumReader.Base64Checksum()
if err != nil {
return out, metadata, fmt.Errorf("failed to get computed checksum, %w", err)
}
// Record the checksum and algorithm that was computed
SetComputedInputChecksums(&metadata, map[string]string{
string(algorithm): checksum,
})
}
return out, metadata, err
}
func getInputAlgorithm(ctx context.Context) (Algorithm, bool, error) {
ctxAlgorithm := getContextInputAlgorithm(ctx)
if ctxAlgorithm == "" {
return "", false, nil
}
algorithm, err := ParseAlgorithm(ctxAlgorithm)
if err != nil {
return "", false, fmt.Errorf(
"failed to parse algorithm, %w", err)
}
return algorithm, true, nil
}
func computeStreamChecksum(algorithm Algorithm, stream io.Reader, computePayloadHash bool) (
checksum string, sha256Checksum string, err error,
) {
hasher, err := NewAlgorithmHash(algorithm)
if err != nil {
return "", "", fmt.Errorf(
"failed to get hasher for checksum algorithm, %w", err)
}
var sha256Hasher hash.Hash
var batchHasher io.Writer = hasher
// Compute payload hash for the protocol. To prevent another handler
// (computePayloadSHA256) re-reading body also compute the SHA256 for
// request signing. If configured checksum algorithm is SHA256, don't
// double wrap stream with another SHA256 hasher.
if computePayloadHash && algorithm != AlgorithmSHA256 {
sha256Hasher = sha256.New()
batchHasher = io.MultiWriter(hasher, sha256Hasher)
}
if stream != nil {
if _, err = io.Copy(batchHasher, stream); err != nil {
return "", "", fmt.Errorf(
"failed to read stream to compute hash, %w", err)
}
}
checksum = string(base64EncodeHashSum(hasher))
if computePayloadHash {
if algorithm != AlgorithmSHA256 {
sha256Checksum = string(hexEncodeHashSum(sha256Hasher))
} else {
sha256Checksum = string(hexEncodeHashSum(hasher))
}
}
return checksum, sha256Checksum, nil
}
func getRequestStreamLength(req *smithyhttp.Request) (int64, error) {
if v := req.ContentLength; v > 0 {
return v, nil
}
if length, ok, err := req.StreamLength(); err != nil {
return 0, fmt.Errorf("failed getting request stream's length, %w", err)
} else if ok {
return length, nil
}
return -1, nil
}
// setMD5Checksum computes the MD5 of the request payload and sets it to the
// Content-MD5 header. Returning the MD5 base64 encoded string or error.
//
// If the MD5 is already set as the Content-MD5 header, that value will be
// returned, and nothing else will be done.
//
// If the payload is empty, no MD5 will be computed. No error will be returned.
// Empty payloads do not have an MD5 value.
//
// Replaces the smithy-go middleware for httpChecksum trait.
func setMD5Checksum(ctx context.Context, req *smithyhttp.Request) (string, error) {
if v := req.Header.Get(contentMD5Header); len(v) != 0 {
return v, nil
}
stream := req.GetStream()
if stream == nil {
return "", nil
}
if !req.IsStreamSeekable() {
return "", fmt.Errorf(
"unseekable stream is not supported for computing md5 checksum")
}
v, err := computeMD5Checksum(stream)
if err != nil {
return "", err
}
if err := req.RewindStream(); err != nil {
return "", fmt.Errorf("failed to rewind stream after computing MD5 checksum, %w", err)
}
// set the 'Content-MD5' header
req.Header.Set(contentMD5Header, string(v))
return string(v), nil
}
| 480 |
aws-sdk-go-v2 | aws | Go | //go:build go1.16
// +build go1.16
package checksum
import (
"bytes"
"context"
"fmt"
"io"
"io/ioutil"
"net/http"
"net/url"
"strings"
"testing"
"testing/iotest"
v4 "github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/logging"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"github.com/google/go-cmp/cmp"
)
// TODO test cases:
// * Retry re-wrapping payload
func TestComputeInputPayloadChecksum(t *testing.T) {
cases := map[string]map[string]struct {
optionsFn func(*computeInputPayloadChecksum)
initContext func(context.Context) context.Context
buildInput middleware.BuildInput
expectErr string
expectBuildErr bool
expectFinalizeErr bool
expectReadErr bool
expectHeader http.Header
expectContentLength int64
expectPayload []byte
expectPayloadHash string
expectChecksumMetadata map[string]string
expectDeferToFinalize bool
expectLogged string
}{
"no op": {
"checksum header set known length": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("https://example.aws")
r.Header.Set(AlgorithmHTTPHeader(AlgorithmCRC32), "AAAAAA==")
r = requestMust(r.SetStream(strings.NewReader("hello world")))
r.ContentLength = 11
return r
}(),
},
expectHeader: http.Header{
"X-Amz-Checksum-Crc32": []string{"AAAAAA=="},
},
expectContentLength: 11,
expectPayload: []byte("hello world"),
expectChecksumMetadata: map[string]string{
"CRC32": "AAAAAA==",
},
},
"checksum header set unknown length": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("https://example.aws")
r.Header.Set(AlgorithmHTTPHeader(AlgorithmCRC32), "AAAAAA==")
r = requestMust(r.SetStream(strings.NewReader("hello world")))
r.ContentLength = -1
return r
}(),
},
expectHeader: http.Header{
"X-Amz-Checksum-Crc32": []string{"AAAAAA=="},
},
expectContentLength: -1,
expectPayload: []byte("hello world"),
expectChecksumMetadata: map[string]string{
"CRC32": "AAAAAA==",
},
},
"no algorithm": {
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("https://example.aws")
r = requestMust(r.SetStream(strings.NewReader("hello world")))
r.ContentLength = 11
return r
}(),
},
expectHeader: http.Header{},
expectContentLength: 11,
expectPayload: []byte("hello world"),
},
"nil stream no algorithm require checksum": {
optionsFn: func(o *computeInputPayloadChecksum) {
o.RequireChecksum = true
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("http://example.aws")
return r
}(),
},
expectContentLength: -1,
expectHeader: http.Header{},
},
},
"build handled": {
"http nil stream": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("http://example.aws")
return r
}(),
},
expectHeader: http.Header{
"X-Amz-Checksum-Crc32": []string{"AAAAAA=="},
},
expectContentLength: -1,
expectPayloadHash: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
expectChecksumMetadata: map[string]string{
"CRC32": "AAAAAA==",
},
},
"http empty stream": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("http://example.aws")
r.ContentLength = 0
r = requestMust(r.SetStream(strings.NewReader("")))
return r
}(),
},
expectHeader: http.Header{
"X-Amz-Checksum-Crc32": []string{"AAAAAA=="},
},
expectContentLength: 0,
expectPayload: []byte{},
expectPayloadHash: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
expectChecksumMetadata: map[string]string{
"CRC32": "AAAAAA==",
},
},
"https empty stream unseekable": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("https://example.aws")
r.ContentLength = 0
r = requestMust(r.SetStream(&bytes.Buffer{}))
return r
}(),
},
expectHeader: http.Header{
"X-Amz-Checksum-Crc32": []string{"AAAAAA=="},
},
expectContentLength: 0,
expectPayload: nil,
expectPayloadHash: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
expectChecksumMetadata: map[string]string{
"CRC32": "AAAAAA==",
},
},
"http empty stream unseekable": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("http://example.aws")
r.ContentLength = 0
r = requestMust(r.SetStream(&bytes.Buffer{}))
return r
}(),
},
expectHeader: http.Header{
"X-Amz-Checksum-Crc32": []string{"AAAAAA=="},
},
expectContentLength: 0,
expectPayload: nil,
expectPayloadHash: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
expectChecksumMetadata: map[string]string{
"CRC32": "AAAAAA==",
},
},
"https nil stream": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("https://example.aws")
return r
}(),
},
expectHeader: http.Header{
"X-Amz-Checksum-Crc32": []string{"AAAAAA=="},
},
expectContentLength: -1,
expectChecksumMetadata: map[string]string{
"CRC32": "AAAAAA==",
},
},
"https empty stream": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("https://example.aws")
r.ContentLength = 0
r = requestMust(r.SetStream(strings.NewReader("")))
return r
}(),
},
expectHeader: http.Header{
"X-Amz-Checksum-Crc32": []string{"AAAAAA=="},
},
expectContentLength: 0,
expectPayload: []byte{},
expectChecksumMetadata: map[string]string{
"CRC32": "AAAAAA==",
},
},
"http no algorithm require checksum": {
optionsFn: func(o *computeInputPayloadChecksum) {
o.RequireChecksum = true
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("http://example.aws")
r.ContentLength = 11
r = requestMust(r.SetStream(bytes.NewReader([]byte("hello world"))))
return r
}(),
},
expectHeader: http.Header{
"Content-Md5": []string{"XrY7u+Ae7tCTyyK7j1rNww=="},
},
expectContentLength: 11,
expectPayload: []byte("hello world"),
expectChecksumMetadata: map[string]string{
"MD5": "XrY7u+Ae7tCTyyK7j1rNww==",
},
},
"http no algorithm require checksum header preset": {
optionsFn: func(o *computeInputPayloadChecksum) {
o.RequireChecksum = true
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("http://example.aws")
r.ContentLength = 11
r.Header.Set("Content-MD5", "XrY7u+Ae7tCTyyK7j1rNww==")
r = requestMust(r.SetStream(bytes.NewReader([]byte("hello world"))))
return r
}(),
},
expectHeader: http.Header{
"Content-Md5": []string{"XrY7u+Ae7tCTyyK7j1rNww=="},
},
expectContentLength: 11,
expectPayload: []byte("hello world"),
expectChecksumMetadata: map[string]string{
"MD5": "XrY7u+Ae7tCTyyK7j1rNww==",
},
},
"https no algorithm require checksum": {
optionsFn: func(o *computeInputPayloadChecksum) {
o.RequireChecksum = true
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("https://example.aws")
r.ContentLength = 11
r = requestMust(r.SetStream(bytes.NewReader([]byte("hello world"))))
return r
}(),
},
expectHeader: http.Header{
"Content-Md5": []string{"XrY7u+Ae7tCTyyK7j1rNww=="},
},
expectContentLength: 11,
expectPayload: []byte("hello world"),
expectChecksumMetadata: map[string]string{
"MD5": "XrY7u+Ae7tCTyyK7j1rNww==",
},
},
"http seekable": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("http://example.aws")
r.ContentLength = 11
r = requestMust(r.SetStream(bytes.NewReader([]byte("hello world"))))
return r
}(),
},
expectHeader: http.Header{
"X-Amz-Checksum-Crc32": []string{"DUoRhQ=="},
},
expectContentLength: 11,
expectPayload: []byte("hello world"),
expectPayloadHash: "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9",
expectChecksumMetadata: map[string]string{
"CRC32": "DUoRhQ==",
},
},
"http payload hash already set": {
initContext: func(ctx context.Context) context.Context {
ctx = setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
ctx = v4.SetPayloadHash(ctx, "somehash")
return ctx
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("http://example.aws")
r.ContentLength = 11
r = requestMust(r.SetStream(bytes.NewReader([]byte("hello world"))))
return r
}(),
},
expectHeader: http.Header{
"X-Amz-Checksum-Crc32": []string{"DUoRhQ=="},
},
expectContentLength: 11,
expectPayload: []byte("hello world"),
expectPayloadHash: "somehash",
expectChecksumMetadata: map[string]string{
"CRC32": "DUoRhQ==",
},
},
"http seekable checksum matches payload hash": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmSHA256))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("http://example.aws")
r.ContentLength = 11
r = requestMust(r.SetStream(bytes.NewReader([]byte("hello world"))))
return r
}(),
},
expectHeader: http.Header{
"X-Amz-Checksum-Sha256": []string{"uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek="},
},
expectContentLength: 11,
expectPayload: []byte("hello world"),
expectPayloadHash: "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9",
expectChecksumMetadata: map[string]string{
"SHA256": "uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=",
},
},
"http payload hash disabled": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
optionsFn: func(o *computeInputPayloadChecksum) {
o.EnableComputePayloadHash = false
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("http://example.aws")
r.ContentLength = 11
r = requestMust(r.SetStream(bytes.NewReader([]byte("hello world"))))
return r
}(),
},
expectHeader: http.Header{
"X-Amz-Checksum-Crc32": []string{"DUoRhQ=="},
},
expectContentLength: 11,
expectPayload: []byte("hello world"),
expectChecksumMetadata: map[string]string{
"CRC32": "DUoRhQ==",
},
},
"https no trailing checksum": {
optionsFn: func(o *computeInputPayloadChecksum) {
o.EnableTrailingChecksum = false
},
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("https://example.aws")
r.ContentLength = 11
r = requestMust(r.SetStream(bytes.NewReader([]byte("hello world"))))
return r
}(),
},
expectHeader: http.Header{
"X-Amz-Checksum-Crc32": []string{"DUoRhQ=="},
},
expectContentLength: 11,
expectPayload: []byte("hello world"),
expectChecksumMetadata: map[string]string{
"CRC32": "DUoRhQ==",
},
},
"with content encoding set": {
optionsFn: func(o *computeInputPayloadChecksum) {
o.EnableTrailingChecksum = false
},
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("https://example.aws")
r.ContentLength = 11
r.Header.Set("Content-Encoding", "gzip")
r = requestMust(r.SetStream(bytes.NewReader([]byte("hello world"))))
return r
}(),
},
expectHeader: http.Header{
"X-Amz-Checksum-Crc32": []string{"DUoRhQ=="},
"Content-Encoding": []string{"gzip"},
},
expectContentLength: 11,
expectPayload: []byte("hello world"),
expectChecksumMetadata: map[string]string{
"CRC32": "DUoRhQ==",
},
},
},
"build error": {
"unknown algorithm": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string("unknown"))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("http://example.aws")
r = requestMust(r.SetStream(bytes.NewBuffer([]byte("hello world"))))
return r
}(),
},
expectErr: "failed to parse algorithm",
expectBuildErr: true,
},
"no algorithm require checksum unseekable stream": {
optionsFn: func(o *computeInputPayloadChecksum) {
o.RequireChecksum = true
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("http://example.aws")
r = requestMust(r.SetStream(bytes.NewBuffer([]byte("hello world"))))
return r
}(),
},
expectErr: "unseekable stream is not supported",
expectBuildErr: true,
},
"http unseekable stream": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("http://example.aws")
r = requestMust(r.SetStream(bytes.NewBuffer([]byte("hello world"))))
return r
}(),
},
expectErr: "unseekable stream is not supported",
expectBuildErr: true,
},
"http stream read error": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("http://example.aws")
r.ContentLength = 128
r = requestMust(r.SetStream(&mockReadSeeker{
Reader: iotest.ErrReader(fmt.Errorf("read error")),
}))
return r
}(),
},
expectErr: "failed to read stream to compute hash",
expectBuildErr: true,
},
"http stream rewind error": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("http://example.aws")
r.ContentLength = 11
r = requestMust(r.SetStream(&errSeekReader{
Reader: strings.NewReader("hello world"),
}))
return r
}(),
},
expectErr: "failed to rewind stream",
expectBuildErr: true,
},
"https no trailing unseekable stream": {
optionsFn: func(o *computeInputPayloadChecksum) {
o.EnableTrailingChecksum = false
},
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("https://example.aws")
r = requestMust(r.SetStream(bytes.NewBuffer([]byte("hello world"))))
return r
}(),
},
expectErr: "unseekable stream is not supported",
expectBuildErr: true,
},
},
"finalize handled": {
"https unseekable": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("https://example.aws")
r.ContentLength = 11
r = requestMust(r.SetStream(bytes.NewBuffer([]byte("hello world"))))
return r
}(),
},
expectHeader: http.Header{
"Content-Encoding": []string{"aws-chunked"},
"X-Amz-Decoded-Content-Length": []string{"11"},
"X-Amz-Trailer": []string{"x-amz-checksum-crc32"},
},
expectContentLength: 52,
expectPayload: []byte("b\r\nhello world\r\n0\r\nx-amz-checksum-crc32:DUoRhQ==\r\n\r\n"),
expectPayloadHash: "STREAMING-UNSIGNED-PAYLOAD-TRAILER",
expectDeferToFinalize: true,
expectChecksumMetadata: map[string]string{
"CRC32": "DUoRhQ==",
},
},
"https unseekable unknown length": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("https://example.aws")
r.ContentLength = -1
r = requestMust(r.SetStream(ioutil.NopCloser(bytes.NewBuffer([]byte("hello world")))))
return r
}(),
},
expectHeader: http.Header{
"Content-Encoding": []string{"aws-chunked"},
"X-Amz-Trailer": []string{"x-amz-checksum-crc32"},
},
expectContentLength: -1,
expectPayload: []byte("b\r\nhello world\r\n0\r\nx-amz-checksum-crc32:DUoRhQ==\r\n\r\n"),
expectPayloadHash: "STREAMING-UNSIGNED-PAYLOAD-TRAILER",
expectDeferToFinalize: true,
expectChecksumMetadata: map[string]string{
"CRC32": "DUoRhQ==",
},
},
"https seekable": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("https://example.aws")
r.ContentLength = 11
r = requestMust(r.SetStream(bytes.NewReader([]byte("hello world"))))
return r
}(),
},
expectHeader: http.Header{
"Content-Encoding": []string{"aws-chunked"},
"X-Amz-Decoded-Content-Length": []string{"11"},
"X-Amz-Trailer": []string{"x-amz-checksum-crc32"},
},
expectContentLength: 52,
expectPayload: []byte("b\r\nhello world\r\n0\r\nx-amz-checksum-crc32:DUoRhQ==\r\n\r\n"),
expectPayloadHash: "STREAMING-UNSIGNED-PAYLOAD-TRAILER",
expectDeferToFinalize: true,
expectChecksumMetadata: map[string]string{
"CRC32": "DUoRhQ==",
},
},
"https seekable unknown length": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("https://example.aws")
r.ContentLength = -1
r = requestMust(r.SetStream(bytes.NewReader([]byte("hello world"))))
return r
}(),
},
expectHeader: http.Header{
"Content-Encoding": []string{"aws-chunked"},
"X-Amz-Decoded-Content-Length": []string{"11"},
"X-Amz-Trailer": []string{"x-amz-checksum-crc32"},
},
expectContentLength: 52,
expectPayload: []byte("b\r\nhello world\r\n0\r\nx-amz-checksum-crc32:DUoRhQ==\r\n\r\n"),
expectPayloadHash: "STREAMING-UNSIGNED-PAYLOAD-TRAILER",
expectDeferToFinalize: true,
expectChecksumMetadata: map[string]string{
"CRC32": "DUoRhQ==",
},
},
"https no compute payload hash": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
optionsFn: func(o *computeInputPayloadChecksum) {
o.EnableComputePayloadHash = false
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("https://example.aws")
r.ContentLength = 11
r = requestMust(r.SetStream(bytes.NewReader([]byte("hello world"))))
return r
}(),
},
expectHeader: http.Header{
"Content-Encoding": []string{"aws-chunked"},
"X-Amz-Decoded-Content-Length": []string{"11"},
"X-Amz-Trailer": []string{"x-amz-checksum-crc32"},
},
expectContentLength: 52,
expectPayload: []byte("b\r\nhello world\r\n0\r\nx-amz-checksum-crc32:DUoRhQ==\r\n\r\n"),
expectDeferToFinalize: true,
expectChecksumMetadata: map[string]string{
"CRC32": "DUoRhQ==",
},
},
"https no decode content length": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
optionsFn: func(o *computeInputPayloadChecksum) {
o.EnableDecodedContentLengthHeader = false
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("https://example.aws")
r.ContentLength = 11
r = requestMust(r.SetStream(bytes.NewReader([]byte("hello world"))))
return r
}(),
},
expectHeader: http.Header{
"Content-Encoding": []string{"aws-chunked"},
"X-Amz-Trailer": []string{"x-amz-checksum-crc32"},
},
expectContentLength: 52,
expectPayloadHash: "STREAMING-UNSIGNED-PAYLOAD-TRAILER",
expectPayload: []byte("b\r\nhello world\r\n0\r\nx-amz-checksum-crc32:DUoRhQ==\r\n\r\n"),
expectDeferToFinalize: true,
expectChecksumMetadata: map[string]string{
"CRC32": "DUoRhQ==",
},
},
"with content encoding set": {
initContext: func(ctx context.Context) context.Context {
return setContextInputAlgorithm(ctx, string(AlgorithmCRC32))
},
buildInput: middleware.BuildInput{
Request: func() *smithyhttp.Request {
r := smithyhttp.NewStackRequest().(*smithyhttp.Request)
r.URL, _ = url.Parse("https://example.aws")
r.ContentLength = 11
r.Header.Set("Content-Encoding", "gzip")
r = requestMust(r.SetStream(bytes.NewReader([]byte("hello world"))))
return r
}(),
},
expectHeader: http.Header{
"X-Amz-Trailer": []string{"x-amz-checksum-crc32"},
"X-Amz-Decoded-Content-Length": []string{"11"},
"Content-Encoding": []string{"gzip", "aws-chunked"},
},
expectContentLength: 52,
expectPayloadHash: "STREAMING-UNSIGNED-PAYLOAD-TRAILER",
expectPayload: []byte("b\r\nhello world\r\n0\r\nx-amz-checksum-crc32:DUoRhQ==\r\n\r\n"),
expectDeferToFinalize: true,
expectChecksumMetadata: map[string]string{
"CRC32": "DUoRhQ==",
},
},
},
}
for name, cs := range cases {
t.Run(name, func(t *testing.T) {
for name, c := range cs {
t.Run(name, func(t *testing.T) {
m := &computeInputPayloadChecksum{
EnableTrailingChecksum: true,
EnableComputePayloadHash: true,
EnableDecodedContentLengthHeader: true,
}
if c.optionsFn != nil {
c.optionsFn(m)
}
ctx := context.Background()
var logged bytes.Buffer
logger := logging.LoggerFunc(
func(classification logging.Classification, format string, v ...interface{}) {
fmt.Fprintf(&logged, format, v...)
},
)
stack := middleware.NewStack("test", smithyhttp.NewStackRequest)
middleware.AddSetLoggerMiddleware(stack, logger)
//------------------------------
// Build handler
//------------------------------
// On return path validate any errors were expected.
stack.Build.Add(middleware.BuildMiddlewareFunc(
"build-assert",
func(ctx context.Context, input middleware.BuildInput, next middleware.BuildHandler) (
out middleware.BuildOutput, metadata middleware.Metadata, err error,
) {
// ignore initial build input for the test case's build input.
out, metadata, err = next.HandleBuild(ctx, c.buildInput)
if err == nil && c.expectBuildErr {
t.Fatalf("expect build error, got none")
}
if !m.buildHandlerRun {
t.Fatalf("expect build handler run")
}
return out, metadata, err
},
), middleware.After)
// Build middleware
stack.Build.Add(m, middleware.After)
// Validate defer to finalize was performed as expected
stack.Build.Add(middleware.BuildMiddlewareFunc(
"assert-defer-to-finalize",
func(ctx context.Context, input middleware.BuildInput, next middleware.BuildHandler) (
out middleware.BuildOutput, metadata middleware.Metadata, err error,
) {
if e, a := c.expectDeferToFinalize, m.deferToFinalizeHandler; e != a {
t.Fatalf("expect %v defer to finalize, got %v", e, a)
}
return next.HandleBuild(ctx, input)
},
), middleware.After)
//------------------------------
// Finalize handler
//------------------------------
if m.EnableTrailingChecksum {
// On return path assert any errors are expected.
stack.Finalize.Add(middleware.FinalizeMiddlewareFunc(
"build-assert",
func(ctx context.Context, input middleware.FinalizeInput, next middleware.FinalizeHandler) (
out middleware.FinalizeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleFinalize(ctx, input)
if err == nil && c.expectFinalizeErr {
t.Fatalf("expect finalize error, got none")
}
return out, metadata, err
},
), middleware.After)
// Add finalize middleware
stack.Finalize.Add(m, middleware.After)
}
//------------------------------
// Request validation
//------------------------------
validateRequestHandler := middleware.HandlerFunc(
func(ctx context.Context, input interface{}) (
output interface{}, metadata middleware.Metadata, err error,
) {
request := input.(*smithyhttp.Request)
if diff := cmp.Diff(c.expectHeader, request.Header); diff != "" {
t.Errorf("expect header to match:\n%s", diff)
}
if e, a := c.expectContentLength, request.ContentLength; e != a {
t.Errorf("expect %v content length, got %v", e, a)
}
stream := request.GetStream()
if e, a := stream != nil, c.expectPayload != nil; e != a {
t.Fatalf("expect nil payload %t, got %t", e, a)
}
if stream == nil {
return
}
actualPayload, err := ioutil.ReadAll(stream)
if err == nil && c.expectReadErr {
t.Fatalf("expected read error, got none")
}
if diff := cmp.Diff(string(c.expectPayload), string(actualPayload)); diff != "" {
t.Errorf("expect payload match:\n%s", diff)
}
payloadHash := v4.GetPayloadHash(ctx)
if e, a := c.expectPayloadHash, payloadHash; e != a {
t.Errorf("expect %v payload hash, got %v", e, a)
}
return &smithyhttp.Response{}, metadata, nil
},
)
if c.initContext != nil {
ctx = c.initContext(ctx)
}
_, metadata, err := stack.HandleMiddleware(ctx, struct{}{}, validateRequestHandler)
if err == nil && len(c.expectErr) != 0 {
t.Fatalf("expected error: %v, got none", c.expectErr)
}
if err != nil && len(c.expectErr) == 0 {
t.Fatalf("expect no error, got %v", err)
}
if err != nil && !strings.Contains(err.Error(), c.expectErr) {
t.Fatalf("expected error %v to contain %v", err, c.expectErr)
}
if c.expectErr != "" {
return
}
if c.expectLogged != "" {
if e, a := c.expectLogged, logged.String(); !strings.Contains(a, e) {
t.Errorf("expected %q logged in:\n%s", e, a)
}
}
// assert computed input checksums metadata
computedMetadata, ok := GetComputedInputChecksums(metadata)
if e, a := ok, (c.expectChecksumMetadata != nil); e != a {
t.Fatalf("expect checksum metadata %t, got %t, %v", e, a, computedMetadata)
}
if c.expectChecksumMetadata != nil {
if diff := cmp.Diff(c.expectChecksumMetadata, computedMetadata); diff != "" {
t.Errorf("expect checksum metadata match\n%s", diff)
}
}
})
}
})
}
}
type mockReadSeeker struct {
io.Reader
}
func (r *mockReadSeeker) Seek(int64, int) (int64, error) {
return 0, nil
}
type errSeekReader struct {
io.Reader
}
func (r *errSeekReader) Seek(offset int64, whence int) (int64, error) {
if whence == io.SeekCurrent {
return 0, nil
}
return 0, fmt.Errorf("seek failed")
}
func requestMust(r *smithyhttp.Request, err error) *smithyhttp.Request {
if err != nil {
panic(err.Error())
}
return r
}
| 959 |
aws-sdk-go-v2 | aws | Go | package checksum
import (
"context"
"github.com/aws/smithy-go/middleware"
)
// setupChecksumContext is the initial middleware that looks up the input
// used to configure checksum behavior. This middleware must be executed before
// input validation step or any other checksum middleware.
type setupInputContext struct {
// GetAlgorithm is a function to get the checksum algorithm of the
// input payload from the input parameters.
//
// Given the input parameter value, the function must return the algorithm
// and true, or false if no algorithm is specified.
GetAlgorithm func(interface{}) (string, bool)
}
// ID for the middleware
func (m *setupInputContext) ID() string {
return "AWSChecksum:SetupInputContext"
}
// HandleInitialize initialization middleware that setups up the checksum
// context based on the input parameters provided in the stack.
func (m *setupInputContext) HandleInitialize(
ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler,
) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
// Check if validation algorithm is specified.
if m.GetAlgorithm != nil {
// check is input resource has a checksum algorithm
algorithm, ok := m.GetAlgorithm(in.Parameters)
if ok && len(algorithm) != 0 {
ctx = setContextInputAlgorithm(ctx, algorithm)
}
}
return next.HandleInitialize(ctx, in)
}
// inputAlgorithmKey is the key set on context used to identify, retrieves the
// request checksum algorithm if present on the context.
type inputAlgorithmKey struct{}
// setContextInputAlgorithm sets the request checksum algorithm on the context.
//
// Scoped to stack values.
func setContextInputAlgorithm(ctx context.Context, value string) context.Context {
return middleware.WithStackValue(ctx, inputAlgorithmKey{}, value)
}
// getContextInputAlgorithm returns the checksum algorithm from the context if
// one was specified. Empty string is returned if one is not specified.
//
// Scoped to stack values.
func getContextInputAlgorithm(ctx context.Context) (v string) {
v, _ = middleware.GetStackValue(ctx, inputAlgorithmKey{}).(string)
return v
}
type setupOutputContext struct {
// GetValidationMode is a function to get the checksum validation
// mode of the output payload from the input parameters.
//
// Given the input parameter value, the function must return the validation
// mode and true, or false if no mode is specified.
GetValidationMode func(interface{}) (string, bool)
}
// ID for the middleware
func (m *setupOutputContext) ID() string {
return "AWSChecksum:SetupOutputContext"
}
// HandleInitialize initialization middleware that setups up the checksum
// context based on the input parameters provided in the stack.
func (m *setupOutputContext) HandleInitialize(
ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler,
) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
// Check if validation mode is specified.
if m.GetValidationMode != nil {
// check is input resource has a checksum algorithm
mode, ok := m.GetValidationMode(in.Parameters)
if ok && len(mode) != 0 {
ctx = setContextOutputValidationMode(ctx, mode)
}
}
return next.HandleInitialize(ctx, in)
}
// outputValidationModeKey is the key set on context used to identify if
// output checksum validation is enabled.
type outputValidationModeKey struct{}
// setContextOutputValidationMode sets the request checksum
// algorithm on the context.
//
// Scoped to stack values.
func setContextOutputValidationMode(ctx context.Context, value string) context.Context {
return middleware.WithStackValue(ctx, outputValidationModeKey{}, value)
}
// getContextOutputValidationMode returns response checksum validation state,
// if one was specified. Empty string is returned if one is not specified.
//
// Scoped to stack values.
func getContextOutputValidationMode(ctx context.Context) (v string) {
v, _ = middleware.GetStackValue(ctx, outputValidationModeKey{}).(string)
return v
}
| 118 |
aws-sdk-go-v2 | aws | Go | //go:build go1.16
// +build go1.16
package checksum
import (
"context"
"testing"
"github.com/aws/smithy-go/middleware"
)
func TestSetupInput(t *testing.T) {
type Params struct {
Value string
}
cases := map[string]struct {
inputParams interface{}
getAlgorithm func(interface{}) (string, bool)
expectValue string
}{
"nil accessor": {
expectValue: "",
},
"found empty": {
inputParams: Params{Value: ""},
getAlgorithm: func(v interface{}) (string, bool) {
vv := v.(Params)
return vv.Value, true
},
expectValue: "",
},
"found not set": {
inputParams: Params{Value: ""},
getAlgorithm: func(v interface{}) (string, bool) {
return "", false
},
expectValue: "",
},
"found": {
inputParams: Params{Value: "abc123"},
getAlgorithm: func(v interface{}) (string, bool) {
vv := v.(Params)
return vv.Value, true
},
expectValue: "abc123",
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
m := setupInputContext{
GetAlgorithm: c.getAlgorithm,
}
_, _, err := m.HandleInitialize(context.Background(),
middleware.InitializeInput{Parameters: c.inputParams},
middleware.InitializeHandlerFunc(
func(ctx context.Context, input middleware.InitializeInput) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
v := getContextInputAlgorithm(ctx)
if e, a := c.expectValue, v; e != a {
t.Errorf("expect value %v, got %v", e, a)
}
return out, metadata, nil
},
))
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
})
}
}
func TestSetupOutput(t *testing.T) {
type Params struct {
Value string
}
cases := map[string]struct {
inputParams interface{}
getValidationMode func(interface{}) (string, bool)
expectValue string
}{
"nil accessor": {
expectValue: "",
},
"found empty": {
inputParams: Params{Value: ""},
getValidationMode: func(v interface{}) (string, bool) {
vv := v.(Params)
return vv.Value, true
},
expectValue: "",
},
"found not set": {
inputParams: Params{Value: ""},
getValidationMode: func(v interface{}) (string, bool) {
return "", false
},
expectValue: "",
},
"found": {
inputParams: Params{Value: "abc123"},
getValidationMode: func(v interface{}) (string, bool) {
vv := v.(Params)
return vv.Value, true
},
expectValue: "abc123",
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
m := setupOutputContext{
GetValidationMode: c.getValidationMode,
}
_, _, err := m.HandleInitialize(context.Background(),
middleware.InitializeInput{Parameters: c.inputParams},
middleware.InitializeHandlerFunc(
func(ctx context.Context, input middleware.InitializeInput) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
v := getContextOutputValidationMode(ctx)
if e, a := c.expectValue, v; e != a {
t.Errorf("expect value %v, got %v", e, a)
}
return out, metadata, nil
},
))
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
})
}
}
| 144 |
aws-sdk-go-v2 | aws | Go | package checksum
import (
"context"
"fmt"
"strings"
"github.com/aws/smithy-go"
"github.com/aws/smithy-go/logging"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// outputValidationAlgorithmsUsedKey is the metadata key for indexing the algorithms
// that were used, by the middleware's validation.
type outputValidationAlgorithmsUsedKey struct{}
// GetOutputValidationAlgorithmsUsed returns the checksum algorithms used
// stored in the middleware Metadata. Returns false if no algorithms were
// stored in the Metadata.
func GetOutputValidationAlgorithmsUsed(m middleware.Metadata) ([]string, bool) {
vs, ok := m.Get(outputValidationAlgorithmsUsedKey{}).([]string)
return vs, ok
}
// SetOutputValidationAlgorithmsUsed stores the checksum algorithms used in the
// middleware Metadata.
func SetOutputValidationAlgorithmsUsed(m *middleware.Metadata, vs []string) {
m.Set(outputValidationAlgorithmsUsedKey{}, vs)
}
// validateOutputPayloadChecksum middleware computes payload checksum of the
// received response and validates with checksum returned by the service.
type validateOutputPayloadChecksum struct {
// Algorithms represents a priority-ordered list of valid checksum
// algorithm that should be validated when present in HTTP response
// headers.
Algorithms []Algorithm
// IgnoreMultipartValidation indicates multipart checksums ending with "-#"
// will be ignored.
IgnoreMultipartValidation bool
// When set the middleware will log when output does not have checksum or
// algorithm to validate.
LogValidationSkipped bool
// When set the middleware will log when the output contains a multipart
// checksum that was, skipped and not validated.
LogMultipartValidationSkipped bool
}
func (m *validateOutputPayloadChecksum) ID() string {
return "AWSChecksum:ValidateOutputPayloadChecksum"
}
// HandleDeserialize is a Deserialize middleware that wraps the HTTP response
// body with an io.ReadCloser that will validate the its checksum.
func (m *validateOutputPayloadChecksum) 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
}
// If there is no validation mode specified nothing is supported.
if mode := getContextOutputValidationMode(ctx); mode != "ENABLED" {
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),
}
}
var expectedChecksum string
var algorithmToUse Algorithm
for _, algorithm := range m.Algorithms {
value := response.Header.Get(AlgorithmHTTPHeader(algorithm))
if len(value) == 0 {
continue
}
expectedChecksum = value
algorithmToUse = algorithm
}
// TODO this must validate the validation mode is set to enabled.
logger := middleware.GetLogger(ctx)
// Skip validation if no checksum algorithm or checksum is available.
if len(expectedChecksum) == 0 || len(algorithmToUse) == 0 {
if m.LogValidationSkipped {
// TODO this probably should have more information about the
// operation output that won't be validated.
logger.Logf(logging.Warn,
"Response has no supported checksum. Not validating response payload.")
}
return out, metadata, nil
}
// Ignore multipart validation
if m.IgnoreMultipartValidation && strings.Contains(expectedChecksum, "-") {
if m.LogMultipartValidationSkipped {
// TODO this probably should have more information about the
// operation output that won't be validated.
logger.Logf(logging.Warn, "Skipped validation of multipart checksum.")
}
return out, metadata, nil
}
body, err := newValidateChecksumReader(response.Body, algorithmToUse, expectedChecksum)
if err != nil {
return out, metadata, fmt.Errorf("failed to create checksum validation reader, %w", err)
}
response.Body = body
// Update the metadata to include the set of the checksum algorithms that
// will be validated.
SetOutputValidationAlgorithmsUsed(&metadata, []string{
string(algorithmToUse),
})
return out, metadata, nil
}
| 132 |
aws-sdk-go-v2 | aws | Go | //go:build go1.16
// +build go1.16
package checksum
import (
"bytes"
"context"
"fmt"
"io/ioutil"
"net/http"
"strings"
"testing"
"testing/iotest"
"github.com/aws/smithy-go/logging"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"github.com/google/go-cmp/cmp"
)
func TestValidateOutputPayloadChecksum(t *testing.T) {
cases := map[string]struct {
response *smithyhttp.Response
validateOptions func(*validateOutputPayloadChecksum)
modifyContext func(context.Context) context.Context
expectHaveAlgorithmsUsed bool
expectAlgorithmsUsed []string
expectErr string
expectReadErr string
expectLogged string
expectPayload []byte
}{
"success": {
modifyContext: func(ctx context.Context) context.Context {
return setContextOutputValidationMode(ctx, "ENABLED")
},
response: &smithyhttp.Response{
Response: &http.Response{
StatusCode: 200,
Header: func() http.Header {
h := http.Header{}
h.Set(AlgorithmHTTPHeader(AlgorithmCRC32), "DUoRhQ==")
return h
}(),
Body: ioutil.NopCloser(strings.NewReader("hello world")),
},
},
expectHaveAlgorithmsUsed: true,
expectAlgorithmsUsed: []string{"CRC32"},
expectPayload: []byte("hello world"),
},
"failure": {
modifyContext: func(ctx context.Context) context.Context {
return setContextOutputValidationMode(ctx, "ENABLED")
},
response: &smithyhttp.Response{
Response: &http.Response{
StatusCode: 200,
Header: func() http.Header {
h := http.Header{}
h.Set(AlgorithmHTTPHeader(AlgorithmCRC32), "AAAAAA==")
return h
}(),
Body: ioutil.NopCloser(strings.NewReader("hello world")),
},
},
expectReadErr: "checksum did not match",
},
"read error": {
modifyContext: func(ctx context.Context) context.Context {
return setContextOutputValidationMode(ctx, "ENABLED")
},
response: &smithyhttp.Response{
Response: &http.Response{
StatusCode: 200,
Header: func() http.Header {
h := http.Header{}
h.Set(AlgorithmHTTPHeader(AlgorithmCRC32), "AAAAAA==")
return h
}(),
Body: ioutil.NopCloser(iotest.ErrReader(fmt.Errorf("some read error"))),
},
},
expectReadErr: "some read error",
},
"unsupported algorithm": {
modifyContext: func(ctx context.Context) context.Context {
return setContextOutputValidationMode(ctx, "ENABLED")
},
response: &smithyhttp.Response{
Response: &http.Response{
StatusCode: 200,
Header: func() http.Header {
h := http.Header{}
h.Set(AlgorithmHTTPHeader("unsupported"), "AAAAAA==")
return h
}(),
Body: ioutil.NopCloser(strings.NewReader("hello world")),
},
},
expectLogged: "no supported checksum",
expectPayload: []byte("hello world"),
},
"no output validation model": {
response: &smithyhttp.Response{
Response: &http.Response{
StatusCode: 200,
Header: func() http.Header {
h := http.Header{}
return h
}(),
Body: ioutil.NopCloser(strings.NewReader("hello world")),
},
},
expectPayload: []byte("hello world"),
},
"unknown output validation model": {
modifyContext: func(ctx context.Context) context.Context {
return setContextOutputValidationMode(ctx, "something else")
},
response: &smithyhttp.Response{
Response: &http.Response{
StatusCode: 200,
Header: func() http.Header {
h := http.Header{}
return h
}(),
Body: ioutil.NopCloser(strings.NewReader("hello world")),
},
},
expectPayload: []byte("hello world"),
},
"success ignore multipart checksum": {
modifyContext: func(ctx context.Context) context.Context {
return setContextOutputValidationMode(ctx, "ENABLED")
},
response: &smithyhttp.Response{
Response: &http.Response{
StatusCode: 200,
Header: func() http.Header {
h := http.Header{}
h.Set(AlgorithmHTTPHeader(AlgorithmCRC32), "DUoRhQ==")
return h
}(),
Body: ioutil.NopCloser(strings.NewReader("hello world")),
},
},
validateOptions: func(o *validateOutputPayloadChecksum) {
o.IgnoreMultipartValidation = true
},
expectHaveAlgorithmsUsed: true,
expectAlgorithmsUsed: []string{"CRC32"},
expectPayload: []byte("hello world"),
},
"success skip ignore multipart checksum": {
modifyContext: func(ctx context.Context) context.Context {
return setContextOutputValidationMode(ctx, "ENABLED")
},
response: &smithyhttp.Response{
Response: &http.Response{
StatusCode: 200,
Header: func() http.Header {
h := http.Header{}
h.Set(AlgorithmHTTPHeader(AlgorithmCRC32), "DUoRhQ==-12")
return h
}(),
Body: ioutil.NopCloser(strings.NewReader("hello world")),
},
},
validateOptions: func(o *validateOutputPayloadChecksum) {
o.IgnoreMultipartValidation = true
},
expectLogged: "Skipped validation of multipart checksum",
expectPayload: []byte("hello world"),
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
var logged bytes.Buffer
ctx := middleware.SetLogger(context.Background(), logging.LoggerFunc(
func(classification logging.Classification, format string, v ...interface{}) {
fmt.Fprintf(&logged, format, v...)
}))
if c.modifyContext != nil {
ctx = c.modifyContext(ctx)
}
validateOutput := validateOutputPayloadChecksum{
Algorithms: []Algorithm{
AlgorithmSHA1, AlgorithmCRC32, AlgorithmCRC32C,
},
LogValidationSkipped: true,
LogMultipartValidationSkipped: true,
}
if c.validateOptions != nil {
c.validateOptions(&validateOutput)
}
out, meta, err := validateOutput.HandleDeserialize(ctx,
middleware.DeserializeInput{},
middleware.DeserializeHandlerFunc(
func(ctx context.Context, input middleware.DeserializeInput) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out.RawResponse = c.response
return out, metadata, nil
},
),
)
if err == nil && len(c.expectErr) != 0 {
t.Fatalf("expect error %v, got none", c.expectErr)
}
if err != nil && len(c.expectErr) == 0 {
t.Fatalf("expect no error, got %v", err)
}
if err != nil && !strings.Contains(err.Error(), c.expectErr) {
t.Fatalf("expect error to contain %v, got %v", c.expectErr, err)
}
if c.expectErr != "" {
return
}
response := out.RawResponse.(*smithyhttp.Response)
actualPayload, err := ioutil.ReadAll(response.Body)
if err == nil && len(c.expectReadErr) != 0 {
t.Fatalf("expected read error: %v, got none", c.expectReadErr)
}
if err != nil && len(c.expectReadErr) == 0 {
t.Fatalf("expect no read error, got %v", err)
}
if err != nil && !strings.Contains(err.Error(), c.expectReadErr) {
t.Fatalf("expected read error %v to contain %v", err, c.expectReadErr)
}
if c.expectReadErr != "" {
return
}
if e, a := c.expectLogged, logged.String(); !strings.Contains(a, e) || !((e == "") == (a == "")) {
t.Errorf("expected %q logged in:\n%s", e, a)
}
if diff := cmp.Diff(string(c.expectPayload), string(actualPayload)); diff != "" {
t.Errorf("expect payload match:\n%s", diff)
}
if err = response.Body.Close(); err != nil {
t.Errorf("expect no close error, got %v", err)
}
values, ok := GetOutputValidationAlgorithmsUsed(meta)
if ok != c.expectHaveAlgorithmsUsed {
t.Errorf("expect metadata to contain algorithms used, %t", c.expectHaveAlgorithmsUsed)
}
if diff := cmp.Diff(c.expectAlgorithmsUsed, values); diff != "" {
t.Errorf("expect algorithms used to match\n%s", diff)
}
})
}
}
| 264 |
aws-sdk-go-v2 | aws | Go | package endpointdiscovery
import (
"sync"
"sync/atomic"
)
// EndpointCache is an LRU cache that holds a series of endpoints
// based on some key. The data structure makes use of a read write
// mutex to enable asynchronous use.
type EndpointCache struct {
endpoints sync.Map
endpointLimit int64
// size is used to count the number elements in the cache.
// The atomic package is used to ensure this size is accurate when
// using multiple goroutines.
size int64
}
// NewEndpointCache will return a newly initialized cache with a limit
// of endpointLimit entries.
func NewEndpointCache(endpointLimit int64) *EndpointCache {
return &EndpointCache{
endpointLimit: endpointLimit,
endpoints: sync.Map{},
}
}
// Get is a concurrent safe get operation that will retrieve an endpoint
// based on endpointKey. A boolean will also be returned to illustrate whether
// or not the endpoint had been found.
func (c *EndpointCache) get(endpointKey string) (Endpoint, bool) {
endpoint, ok := c.endpoints.Load(endpointKey)
if !ok {
return Endpoint{}, false
}
ev := endpoint.(Endpoint)
ev.Prune()
c.endpoints.Store(endpointKey, ev)
return endpoint.(Endpoint), true
}
// Has returns if the enpoint cache contains a valid entry for the endpoint key
// provided.
func (c *EndpointCache) Has(endpointKey string) bool {
_, found := c.Get(endpointKey)
return found
}
// Get will retrieve a weighted address based off of the endpoint key. If an endpoint
// should be retrieved, due to not existing or the current endpoint has expired
// the Discoverer object that was passed in will attempt to discover a new endpoint
// and add that to the cache.
func (c *EndpointCache) Get(endpointKey string) (WeightedAddress, bool) {
endpoint, ok := c.get(endpointKey)
if !ok {
return WeightedAddress{}, false
}
return endpoint.GetValidAddress()
}
// Add is a concurrent safe operation that will allow new endpoints to be added
// to the cache. If the cache is full, the number of endpoints equal endpointLimit,
// then this will remove the oldest entry before adding the new endpoint.
func (c *EndpointCache) Add(endpoint Endpoint) {
// de-dups multiple adds of an endpoint with a pre-existing key
if iface, ok := c.endpoints.Load(endpoint.Key); ok {
e := iface.(Endpoint)
if e.Len() > 0 {
return
}
}
size := atomic.AddInt64(&c.size, 1)
if size > 0 && size > c.endpointLimit {
c.deleteRandomKey()
}
c.endpoints.Store(endpoint.Key, endpoint)
}
// deleteRandomKey will delete a random key from the cache. If
// no key was deleted false will be returned.
func (c *EndpointCache) deleteRandomKey() bool {
atomic.AddInt64(&c.size, -1)
found := false
c.endpoints.Range(func(key, value interface{}) bool {
found = true
c.endpoints.Delete(key)
return false
})
return found
}
| 99 |
aws-sdk-go-v2 | aws | Go | package endpointdiscovery
import (
"net/url"
"testing"
"time"
)
func TestEndpointCache_Get_prune(t *testing.T) {
c := NewEndpointCache(2)
c.Add(Endpoint{
Key: "foo",
Addresses: []WeightedAddress{
{
URL: &url.URL{
Host: "foo.amazonaws.com",
},
Expired: time.Now().Add(5 * time.Minute),
},
{
URL: &url.URL{
Host: "bar.amazonaws.com",
},
Expired: time.Now().Add(5 * -time.Minute),
},
},
})
load, _ := c.endpoints.Load("foo")
if ev := load.(Endpoint); len(ev.Addresses) != 2 {
t.Errorf("expected two weighted addresses")
}
weightedAddress, ok := c.Get("foo")
if !ok {
t.Errorf("expect weighted address, got none")
}
if e, a := "foo.amazonaws.com", weightedAddress.URL.Host; e != a {
t.Errorf("expect %v, got %v", e, a)
}
load, _ = c.endpoints.Load("foo")
if ev := load.(Endpoint); len(ev.Addresses) != 1 {
t.Errorf("expected one weighted address")
}
}
| 47 |
aws-sdk-go-v2 | aws | Go | /*
Package endpointdiscovery provides a feature implemented in the AWS SDK for Go V2 that
allows client to fetch a valid endpoint to serve an API request. Discovered
endpoints are stored in an internal thread-safe cache to reduce the number
of calls made to fetch the endpoint.
Endpoint discovery stores endpoint by associating to a generated cache key.
Cache key is built using service-modeled sdkId and any service-defined input
identifiers provided by the customer.
Endpoint cache keys follow the grammar:
key = sdkId.identifiers
identifiers = map[string]string
The endpoint discovery cache implementation is internal. Clients resolves the
cache size to 10 entries. Each entry may contain multiple host addresses as
returned by the service.
Each discovered endpoint has a TTL associated to it, and are evicted from
cache lazily i.e. when client tries to retrieve an endpoint but finds an
expired entry instead.
Endpoint discovery feature can be turned on by setting the
`AWS_ENABLE_ENDPOINT_DISCOVERY` env variable to TRUE.
By default, the feature is set to AUTO - indicating operations that require
endpoint discovery always use it. To completely turn off the feature, one
should set the value as FALSE. Similar configuration rules apply for shared
config file where key is `endpoint_discovery_enabled`.
*/
package endpointdiscovery
| 34 |
aws-sdk-go-v2 | aws | Go | package endpointdiscovery
import (
"net/url"
"time"
)
// Endpoint represents an endpoint used in endpoint discovery.
type Endpoint struct {
Key string
Addresses WeightedAddresses
}
// WeightedAddresses represents a list of WeightedAddress.
type WeightedAddresses []WeightedAddress
// WeightedAddress represents an address with a given weight.
type WeightedAddress struct {
URL *url.URL
Expired time.Time
}
// HasExpired will return whether or not the endpoint has expired with
// the exception of a zero expiry meaning does not expire.
func (e WeightedAddress) HasExpired() bool {
return e.Expired.Before(time.Now())
}
// Add will add a given WeightedAddress to the address list of Endpoint.
func (e *Endpoint) Add(addr WeightedAddress) {
e.Addresses = append(e.Addresses, addr)
}
// Len returns the number of valid endpoints where valid means the endpoint
// has not expired.
func (e *Endpoint) Len() int {
validEndpoints := 0
for _, endpoint := range e.Addresses {
if endpoint.HasExpired() {
continue
}
validEndpoints++
}
return validEndpoints
}
// GetValidAddress will return a non-expired weight endpoint
func (e *Endpoint) GetValidAddress() (WeightedAddress, bool) {
for i := 0; i < len(e.Addresses); i++ {
we := e.Addresses[i]
if we.HasExpired() {
continue
}
we.URL = cloneURL(we.URL)
return we, true
}
return WeightedAddress{}, false
}
// Prune will prune the expired addresses from the endpoint by allocating a new []WeightAddress.
// This is not concurrent safe, and should be called from a single owning thread.
func (e *Endpoint) Prune() bool {
validLen := e.Len()
if validLen == len(e.Addresses) {
return false
}
wa := make([]WeightedAddress, 0, validLen)
for i := range e.Addresses {
if e.Addresses[i].HasExpired() {
continue
}
wa = append(wa, e.Addresses[i])
}
e.Addresses = wa
return true
}
func cloneURL(u *url.URL) (clone *url.URL) {
clone = &url.URL{}
*clone = *u
if u.User != nil {
user := *u.User
clone.User = &user
}
return clone
}
| 95 |
aws-sdk-go-v2 | aws | Go | package endpointdiscovery
import (
"net/url"
"reflect"
"strconv"
"testing"
"time"
)
func Test_cloneURL(t *testing.T) {
tests := []struct {
value *url.URL
wantClone *url.URL
}{
{
value: &url.URL{
Scheme: "https",
Opaque: "foo",
User: nil,
Host: "amazonaws.com",
Path: "/",
RawPath: "/",
ForceQuery: true,
RawQuery: "thing=value",
Fragment: "1234",
RawFragment: "1234",
},
wantClone: &url.URL{
Scheme: "https",
Opaque: "foo",
User: nil,
Host: "amazonaws.com",
Path: "/",
RawPath: "/",
ForceQuery: true,
RawQuery: "thing=value",
Fragment: "1234",
RawFragment: "1234",
},
},
{
value: &url.URL{
Scheme: "https",
Opaque: "foo",
User: url.UserPassword("NOT", "VALID"),
Host: "amazonaws.com",
Path: "/",
RawPath: "/",
ForceQuery: true,
RawQuery: "thing=value",
Fragment: "1234",
RawFragment: "1234",
},
wantClone: &url.URL{
Scheme: "https",
Opaque: "foo",
User: url.UserPassword("NOT", "VALID"),
Host: "amazonaws.com",
Path: "/",
RawPath: "/",
ForceQuery: true,
RawQuery: "thing=value",
Fragment: "1234",
RawFragment: "1234",
},
},
}
for i, tt := range tests {
t.Run(strconv.Itoa(i), func(t *testing.T) {
gotClone := cloneURL(tt.value)
if gotClone == tt.value {
t.Errorf("expct clone URL to not be same pointer address")
}
if tt.value.User != nil {
if tt.value.User == gotClone.User {
t.Errorf("expct cloned Userinfo to not be same pointer address")
}
}
if !reflect.DeepEqual(gotClone, tt.wantClone) {
t.Errorf("cloneURL() = %v, want %v", gotClone, tt.wantClone)
}
})
}
}
func TestEndpoint_Prune(t *testing.T) {
endpoint := Endpoint{}
endpoint.Add(WeightedAddress{
URL: &url.URL{},
Expired: time.Now().Add(5 * time.Minute),
})
initial := endpoint.Addresses
if e, a := false, endpoint.Prune(); e != a {
t.Errorf("expect prune %v, got %v", e, a)
}
if e, a := &initial[0], &endpoint.Addresses[0]; e != a {
t.Errorf("expect slice address to be same")
}
endpoint.Add(WeightedAddress{
URL: &url.URL{},
Expired: time.Now().Add(5 * -time.Minute),
})
initial = endpoint.Addresses
if e, a := true, endpoint.Prune(); e != a {
t.Errorf("expect prune %v, got %v", e, a)
}
if e, a := &initial[0], &endpoint.Addresses[0]; e == a {
t.Errorf("expect slice address to be different")
}
if e, a := 1, endpoint.Len(); e != a {
t.Errorf("expect slice length %v, got %v", e, a)
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT.
package endpointdiscovery
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.7.28"
| 7 |
aws-sdk-go-v2 | aws | Go | package endpointdiscovery
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"github.com/aws/smithy-go/logging"
"github.com/aws/smithy-go/middleware"
)
// DiscoverEndpointOptions are optionals used with DiscoverEndpoint operation.
type DiscoverEndpointOptions struct {
// EndpointResolverUsedForDiscovery is the endpoint resolver used to
// resolve an endpoint for discovery api call.
EndpointResolverUsedForDiscovery interface{}
// DisableHTTPS will disable tls for endpoint discovery call and
// subsequent discovered endpoint if service did not return an
// endpoint scheme.
DisableHTTPS bool
// Logger to log warnings or debug statements.
Logger logging.Logger
}
// DiscoverEndpoint is a serialize step middleware used to discover endpoint
// for an API operation.
type DiscoverEndpoint struct {
// Options provides optional settings used with
// Discover Endpoint operation.
Options []func(*DiscoverEndpointOptions)
// DiscoverOperation represents the endpoint discovery operation that
// returns an Endpoint or error.
DiscoverOperation func(ctx context.Context, input interface{}, options ...func(*DiscoverEndpointOptions)) (WeightedAddress, error)
// EndpointDiscoveryEnableState represents the customer configuration for endpoint
// discovery feature.
EndpointDiscoveryEnableState aws.EndpointDiscoveryEnableState
// EndpointDiscoveryRequired states if an operation requires to perform
// endpoint discovery.
EndpointDiscoveryRequired bool
}
// ID represents the middleware identifier
func (*DiscoverEndpoint) ID() string {
return "DiscoverEndpoint"
}
// HandleSerialize is the serialize step function handler that must be placed after
// "ResolveEndpoint" middleware, but before "OperationSerializer" middleware.
func (d *DiscoverEndpoint) HandleSerialize(
ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler,
) (out middleware.SerializeOutput, metadata middleware.Metadata, err error) {
// if endpoint discovery is explicitly disabled, skip this workflow
if d.EndpointDiscoveryEnableState == aws.EndpointDiscoveryDisabled {
return next.HandleSerialize(ctx, in)
}
// if operation does not require endpoint discovery, and endpoint discovery is not explicitly enabled,
// skip this workflow
if !d.EndpointDiscoveryRequired && d.EndpointDiscoveryEnableState != aws.EndpointDiscoveryEnabled {
return next.HandleSerialize(ctx, in)
}
// when custom endpoint is provided
if es := awsmiddleware.GetEndpointSource(ctx); es == aws.EndpointSourceCustom {
// error if endpoint discovery was explicitly enabled
if d.EndpointDiscoveryEnableState == aws.EndpointDiscoveryEnabled {
return middleware.SerializeOutput{}, middleware.Metadata{},
fmt.Errorf("Invalid configuration: endpoint discovery is enabled, but a custom endpoint is provided")
}
// else skip this workflow
return next.HandleSerialize(ctx, in)
}
// fetch address using discover operation
weightedAddress, err := d.DiscoverOperation(ctx, in.Parameters, d.Options...)
if err != nil {
return middleware.SerializeOutput{}, middleware.Metadata{}, err
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return middleware.SerializeOutput{}, middleware.Metadata{},
fmt.Errorf("expected request to be of type *smithyhttp.Request, got %T", in.Request)
}
if weightedAddress.URL != nil {
// assign discovered endpoint to request url
req.URL = weightedAddress.URL
}
return next.HandleSerialize(ctx, in)
}
| 104 |
aws-sdk-go-v2 | aws | Go | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT.
package eventstreamtesting
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.0.65"
| 7 |
aws-sdk-go-v2 | aws | Go | // Package eventstreamtesting implements helper utilities for event stream protocol testing.
package eventstreamtesting
import (
"bytes"
"context"
"crypto/tls"
"fmt"
"io"
"net/http"
"net/http/httptest"
"reflect"
"strings"
"sync"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream"
"github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream/eventstreamapi"
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
"github.com/aws/aws-sdk-go-v2/credentials"
"golang.org/x/net/http2"
)
const (
errClientDisconnected = "client disconnected"
errStreamClosed = "http2: stream closed"
)
func setupServer(server *httptest.Server) aws.HTTPClient {
server.Config.TLSConfig = &tls.Config{
InsecureSkipVerify: true,
}
if err := http2.ConfigureServer(server.Config, nil); err != nil {
panic(err)
}
server.Config.TLSConfig.NextProtos = []string{http2.NextProtoTLS}
server.TLS = server.Config.TLSConfig
server.StartTLS()
buildableClient := awshttp.NewBuildableClient().WithTransportOptions(func(transport *http.Transport) {
transport.ForceAttemptHTTP2 = true
transport.TLSClientConfig = &tls.Config{
InsecureSkipVerify: true,
}
})
return buildableClient
}
// SetupEventStream configures an HTTPS event stream testing server.
func SetupEventStream(
t *testing.T, handler http.Handler,
) (
cfg aws.Config, cleanupFn func(), err error,
) {
server := httptest.NewUnstartedServer(handler)
client := setupServer(server)
cleanupFn = func() {
server.Close()
}
cfg.Credentials = credentials.NewStaticCredentialsProvider("KEYID", "SECRET", "TOKEN")
cfg.HTTPClient = client
cfg.EndpointResolver = aws.EndpointResolverFunc(func(service, region string) (aws.Endpoint, error) {
return aws.Endpoint{URL: server.URL}, nil
})
return cfg, cleanupFn, nil
}
// StaticResponse provides a way to define an HTTP event stream server that provides a fixed
// static response.
type StaticResponse struct {
StatusCode int
Body []byte
}
// ServeEventStream provides serving EventStream messages from a HTTP server to
// the client. The events are sent sequentially to the client without delay.
type ServeEventStream struct {
T *testing.T
BiDirectional bool
StaticResponse *StaticResponse
Events []eventstream.Message
ClientEvents []eventstream.Message
ForceCloseAfter time.Duration
requestsIdx int
}
// ServeHTTP serves an HTTP client request
func (s ServeEventStream) ServeHTTP(w http.ResponseWriter, r *http.Request) {
if s.StaticResponse != nil {
w.WriteHeader(s.StaticResponse.StatusCode)
w.(http.Flusher).Flush()
if _, err := w.Write(s.StaticResponse.Body); err != nil {
s.T.Errorf("failed to write response body error: %v", err)
}
return
}
if s.BiDirectional {
s.serveBiDirectionalStream(w, r)
} else {
s.serveReadOnlyStream(w, r)
}
}
func (s *ServeEventStream) serveReadOnlyStream(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
w.(http.Flusher).Flush()
encoder := eventstream.NewEncoder()
for _, event := range s.Events {
encoder.Encode(flushWriter{w}, event)
}
}
func (s *ServeEventStream) serveBiDirectionalStream(w http.ResponseWriter, r *http.Request) {
var wg sync.WaitGroup
ctx := context.Background()
if s.ForceCloseAfter > 0 {
var cancelFunc func()
ctx, cancelFunc = context.WithTimeout(context.Background(), s.ForceCloseAfter)
defer cancelFunc()
}
var (
err error
m sync.Mutex
)
wg.Add(1)
go func() {
defer wg.Done()
readErr := s.readEvents(ctx, r)
m.Lock()
if readErr != nil && err == nil {
err = readErr
}
m.Unlock()
}()
w.(http.Flusher).Flush()
writeErr := s.writeEvents(ctx, w)
m.Lock()
if writeErr != nil && err == nil {
err = writeErr
}
m.Unlock()
wg.Wait()
if err != nil && isError(err) {
s.T.Error(err.Error())
}
}
func isError(err error) bool {
switch err.(type) {
case http2.StreamError:
return false
}
for _, s := range []string{errClientDisconnected, errStreamClosed} {
if strings.Contains(err.Error(), s) {
return false
}
}
return true
}
func (s ServeEventStream) readEvents(ctx context.Context, r *http.Request) error {
signBuffer := make([]byte, 1024)
messageBuffer := make([]byte, 1024)
decoder := eventstream.NewDecoder()
for {
select {
case <-ctx.Done():
return nil
default:
}
// unwrap signing envelope
signedMessage, err := decoder.Decode(r.Body, signBuffer)
if err != nil {
if err == io.EOF {
return nil
}
return err
}
// empty payload is expected for the last signing message
if len(signedMessage.Payload) == 0 {
break
}
// get service event message from payload
msg, err := decoder.Decode(bytes.NewReader(signedMessage.Payload), messageBuffer)
if err != nil {
if err == io.EOF {
return nil
}
return err
}
if len(s.ClientEvents) > 0 {
i := s.requestsIdx
s.requestsIdx++
if e, a := s.ClientEvents[i], msg; !reflect.DeepEqual(e, a) {
return fmt.Errorf("expected %v, got %v", e, a)
}
}
}
return nil
}
func (s *ServeEventStream) writeEvents(ctx context.Context, w http.ResponseWriter) error {
encoder := eventstream.NewEncoder()
var event eventstream.Message
pendingEvents := s.Events
for len(pendingEvents) > 0 {
event, pendingEvents = pendingEvents[0], pendingEvents[1:]
select {
case <-ctx.Done():
return nil
default:
err := encoder.Encode(flushWriter{w}, event)
if err != nil {
if err == io.EOF {
return nil
}
return fmt.Errorf("expected no error encoding event, got %v", err)
}
}
}
return nil
}
type flushWriter struct {
w io.Writer
}
func (fw flushWriter) Write(p []byte) (n int, err error) {
n, err = fw.w.Write(p)
if f, ok := fw.w.(http.Flusher); ok {
f.Flush()
}
return
}
// EventMessageTypeHeader is an event message type header for specifying an
// event is an message type.
var EventMessageTypeHeader = eventstream.Header{
Name: eventstreamapi.MessageTypeHeader,
Value: eventstream.StringValue(eventstreamapi.EventMessageType),
}
// EventExceptionTypeHeader is an event exception type header for specifying an
// event is an exception type.
var EventExceptionTypeHeader = eventstream.Header{
Name: eventstreamapi.MessageTypeHeader,
Value: eventstream.StringValue(eventstreamapi.ExceptionMessageType),
}
| 284 |
aws-sdk-go-v2 | aws | Go | package integrationtest
import (
"context"
"crypto/rand"
"fmt"
"github.com/aws/smithy-go/middleware"
"io"
"log"
"os"
"strings"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/config"
)
// LoadConfigWithDefaultRegion loads the default configuration for the SDK, and
// falls back to a default region if one is not specified.
func LoadConfigWithDefaultRegion(defaultRegion string) (cfg aws.Config, err error) {
var lm aws.ClientLogMode
if strings.EqualFold(os.Getenv("AWS_DEBUG_REQUEST"), "true") {
lm |= aws.LogRequest
} else if strings.EqualFold(os.Getenv("AWS_DEBUG_REQUEST_BODY"), "true") {
lm |= aws.LogRequestWithBody
}
cfg, err = config.LoadDefaultConfig(context.Background(),
config.WithClientLogMode(lm),
config.WithAPIOptions([]func(*middleware.Stack) error{
RemoveOperationInputValidationMiddleware,
}),
config.WithDefaultRegion(defaultRegion),
)
if err != nil {
return cfg, err
}
return cfg, nil
}
type logger struct{}
func (logger) Logf(format string, args ...interface{}) {
log.Printf(format, args...)
}
// UniqueID returns a unique UUID-like identifier for use in generating
// resources for integration tests.
func UniqueID() string {
uuid := make([]byte, 16)
io.ReadFull(rand.Reader, uuid)
return fmt.Sprintf("%x", uuid)
}
| 56 |
aws-sdk-go-v2 | aws | Go | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT.
package integrationtest
// goModuleVersion is the tagged release for this module
const goModuleVersion = "tip"
| 7 |
aws-sdk-go-v2 | aws | Go | package integrationtest
import "github.com/aws/smithy-go/middleware"
// RemoveOperationInputValidationMiddleware removes the validation middleware
// from the stack.
func RemoveOperationInputValidationMiddleware(stack *middleware.Stack) error {
stack.Initialize.Remove("OperationInputValidation")
return nil
}
| 11 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package acm
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/acm"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListCertificates(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := acm.NewFromConfig(cfg)
params := &acm.ListCertificatesInput{}
_, err = client.ListCertificates(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_GetCertificate(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := acm.NewFromConfig(cfg)
params := &acm.GetCertificateInput{
CertificateArn: aws.String("arn:aws:acm:region:123456789012:certificate/12345678-1234-1234-1234-123456789012"),
}
_, err = client.GetCertificate(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 66 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package apigateway
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/apigateway"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_GetDomainNames(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := apigateway.NewFromConfig(cfg)
params := &apigateway.GetDomainNamesInput{}
_, err = client.GetDomainNames(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_CreateUsagePlanKey(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := apigateway.NewFromConfig(cfg)
params := &apigateway.CreateUsagePlanKeyInput{
KeyId: aws.String("bar"),
KeyType: aws.String("fixx"),
UsagePlanId: aws.String("foo"),
}
_, err = client.CreateUsagePlanKey(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 67 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package applicationautoscaling
import (
"context"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/applicationautoscaling"
"github.com/aws/aws-sdk-go-v2/service/applicationautoscaling/types"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_DescribeScalableTargets(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := applicationautoscaling.NewFromConfig(cfg)
params := &applicationautoscaling.DescribeScalableTargetsInput{
ServiceNamespace: types.ServiceNamespaceEc2,
}
_, err = client.DescribeScalableTargets(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
| 35 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package applicationdiscoveryservice
import (
"context"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/applicationdiscoveryservice"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_DescribeAgents(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := applicationdiscoveryservice.NewFromConfig(cfg)
params := &applicationdiscoveryservice.DescribeAgentsInput{}
_, err = client.DescribeAgents(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
| 32 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package appstream
import (
"context"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/appstream"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_DescribeStacks(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := appstream.NewFromConfig(cfg)
params := &appstream.DescribeStacksInput{}
_, err = client.DescribeStacks(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
| 32 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package athena
import (
"context"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/athena"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_ListNamedQueries(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := athena.NewFromConfig(cfg)
params := &athena.ListNamedQueriesInput{}
_, err = client.ListNamedQueries(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
| 32 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package autoscaling
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/autoscaling"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_DescribeScalingProcessTypes(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := autoscaling.NewFromConfig(cfg)
params := &autoscaling.DescribeScalingProcessTypesInput{}
_, err = client.DescribeScalingProcessTypes(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_CreateLaunchConfiguration(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := autoscaling.NewFromConfig(cfg)
params := &autoscaling.CreateLaunchConfigurationInput{
ImageId: aws.String("ami-12345678"),
InstanceType: aws.String("m1.small"),
LaunchConfigurationName: aws.String("hello, world"),
}
_, err = client.CreateLaunchConfiguration(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 67 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package batch
import (
"context"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/batch"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_DescribeComputeEnvironments(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := batch.NewFromConfig(cfg)
params := &batch.DescribeComputeEnvironmentsInput{}
_, err = client.DescribeComputeEnvironments(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
| 32 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package cloudformation
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/cloudformation"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListStacks(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := cloudformation.NewFromConfig(cfg)
params := &cloudformation.ListStacksInput{}
_, err = client.ListStacks(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_CreateStack(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := cloudformation.NewFromConfig(cfg)
params := &cloudformation.CreateStackInput{
StackName: aws.String("fakestack"),
TemplateURL: aws.String("http://s3.amazonaws.com/foo/bar"),
}
_, err = client.CreateStack(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 66 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package cloudfront
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/cloudfront"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListCloudFrontOriginAccessIdentities(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := cloudfront.NewFromConfig(cfg)
params := &cloudfront.ListCloudFrontOriginAccessIdentitiesInput{}
_, err = client.ListCloudFrontOriginAccessIdentities(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_GetDistribution(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := cloudfront.NewFromConfig(cfg)
params := &cloudfront.GetDistributionInput{
Id: aws.String("fake-id"),
}
_, err = client.GetDistribution(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package cloudhsmv2
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/cloudhsmv2"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_DescribeClusters(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := cloudhsmv2.NewFromConfig(cfg)
params := &cloudhsmv2.DescribeClustersInput{}
_, err = client.DescribeClusters(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_ListTags(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := cloudhsmv2.NewFromConfig(cfg)
params := &cloudhsmv2.ListTagsInput{
ResourceId: aws.String("bogus-arn"),
}
_, err = client.ListTags(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package cloudsearch
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/cloudsearch"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_DescribeDomains(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := cloudsearch.NewFromConfig(cfg)
params := &cloudsearch.DescribeDomainsInput{}
_, err = client.DescribeDomains(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeIndexFields(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := cloudsearch.NewFromConfig(cfg)
params := &cloudsearch.DescribeIndexFieldsInput{
DomainName: aws.String("fakedomain"),
}
_, err = client.DescribeIndexFields(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package cloudtrail
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/cloudtrail"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_DescribeTrails(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := cloudtrail.NewFromConfig(cfg)
params := &cloudtrail.DescribeTrailsInput{}
_, err = client.DescribeTrails(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DeleteTrail(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := cloudtrail.NewFromConfig(cfg)
params := &cloudtrail.DeleteTrailInput{
Name: aws.String("faketrail"),
}
_, err = client.DeleteTrail(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package cloudwatch
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/cloudwatch"
"github.com/aws/aws-sdk-go-v2/service/cloudwatch/types"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListMetrics(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := cloudwatch.NewFromConfig(cfg)
params := &cloudwatch.ListMetricsInput{
Namespace: aws.String("AWS/EC2"),
}
_, err = client.ListMetrics(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_SetAlarmState(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := cloudwatch.NewFromConfig(cfg)
params := &cloudwatch.SetAlarmStateInput{
AlarmName: aws.String("abc"),
StateReason: aws.String("xyz"),
StateValue: types.StateValue("mno"),
}
_, err = client.SetAlarmState(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 69 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package codebuild
import (
"context"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/codebuild"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_ListBuilds(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := codebuild.NewFromConfig(cfg)
params := &codebuild.ListBuildsInput{}
_, err = client.ListBuilds(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
| 32 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package codecommit
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/codecommit"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListRepositories(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := codecommit.NewFromConfig(cfg)
params := &codecommit.ListRepositoriesInput{}
_, err = client.ListRepositories(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_ListBranches(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := codecommit.NewFromConfig(cfg)
params := &codecommit.ListBranchesInput{
RepositoryName: aws.String("fake-repo"),
}
_, err = client.ListBranches(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 64 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package codedeploy
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/codedeploy"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListApplications(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := codedeploy.NewFromConfig(cfg)
params := &codedeploy.ListApplicationsInput{}
_, err = client.ListApplications(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_GetDeployment(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := codedeploy.NewFromConfig(cfg)
params := &codedeploy.GetDeploymentInput{
DeploymentId: aws.String("d-USUAELQEX"),
}
_, err = client.GetDeployment(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 64 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.