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 fms
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"
)
// Permanently deletes an Firewall Manager protocols list.
func (c *Client) DeleteProtocolsList(ctx context.Context, params *DeleteProtocolsListInput, optFns ...func(*Options)) (*DeleteProtocolsListOutput, error) {
if params == nil {
params = &DeleteProtocolsListInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteProtocolsList", params, optFns, c.addOperationDeleteProtocolsListMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteProtocolsListOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteProtocolsListInput struct {
// The ID of the protocols list that you want to delete. You can retrieve this ID
// from PutProtocolsList , ListProtocolsLists , and GetProtocolsLost .
//
// This member is required.
ListId *string
noSmithyDocumentSerde
}
type DeleteProtocolsListOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteProtocolsListMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteProtocolsList{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteProtocolsList{}, 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 = addOpDeleteProtocolsListValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteProtocolsList(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_opDeleteProtocolsList(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "DeleteProtocolsList",
}
}
| 121 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the specified ResourceSet .
func (c *Client) DeleteResourceSet(ctx context.Context, params *DeleteResourceSetInput, optFns ...func(*Options)) (*DeleteResourceSetOutput, error) {
if params == nil {
params = &DeleteResourceSetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteResourceSet", params, optFns, c.addOperationDeleteResourceSetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteResourceSetOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteResourceSetInput struct {
// A unique identifier for the resource set, used in a request to refer to the
// resource set.
//
// This member is required.
Identifier *string
noSmithyDocumentSerde
}
type DeleteResourceSetOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteResourceSetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteResourceSet{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteResourceSet{}, 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 = addOpDeleteResourceSetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteResourceSet(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_opDeleteResourceSet(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "DeleteResourceSet",
}
}
| 121 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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 an Firewall Manager administrator account. To set a different
// account as an Firewall Manager administrator, submit a PutAdminAccount request.
// To set an account as a default administrator account, you must submit an
// AssociateAdminAccount request. Disassociation of the default administrator
// account follows the first in, last out principle. If you are the default
// administrator, all Firewall Manager administrators within the organization must
// first disassociate their accounts before you can disassociate your account.
func (c *Client) DisassociateAdminAccount(ctx context.Context, params *DisassociateAdminAccountInput, optFns ...func(*Options)) (*DisassociateAdminAccountOutput, error) {
if params == nil {
params = &DisassociateAdminAccountInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DisassociateAdminAccount", params, optFns, c.addOperationDisassociateAdminAccountMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DisassociateAdminAccountOutput)
out.ResultMetadata = metadata
return out, nil
}
type DisassociateAdminAccountInput struct {
noSmithyDocumentSerde
}
type DisassociateAdminAccountOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDisassociateAdminAccountMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDisassociateAdminAccount{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDisassociateAdminAccount{}, 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_opDisassociateAdminAccount(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_opDisassociateAdminAccount(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "DisassociateAdminAccount",
}
}
| 117 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Disassociates a Firewall Manager policy administrator from a third-party
// firewall tenant. When you call DisassociateThirdPartyFirewall , the third-party
// firewall vendor deletes all of the firewalls that are associated with the
// account.
func (c *Client) DisassociateThirdPartyFirewall(ctx context.Context, params *DisassociateThirdPartyFirewallInput, optFns ...func(*Options)) (*DisassociateThirdPartyFirewallOutput, error) {
if params == nil {
params = &DisassociateThirdPartyFirewallInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DisassociateThirdPartyFirewall", params, optFns, c.addOperationDisassociateThirdPartyFirewallMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DisassociateThirdPartyFirewallOutput)
out.ResultMetadata = metadata
return out, nil
}
type DisassociateThirdPartyFirewallInput struct {
// The name of the third-party firewall vendor.
//
// This member is required.
ThirdPartyFirewall types.ThirdPartyFirewall
noSmithyDocumentSerde
}
type DisassociateThirdPartyFirewallOutput struct {
// The current status for the disassociation of a Firewall Manager administrators
// account with a third-party firewall.
ThirdPartyFirewallStatus types.ThirdPartyFirewallAssociationStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDisassociateThirdPartyFirewallMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDisassociateThirdPartyFirewall{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDisassociateThirdPartyFirewall{}, 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 = addOpDisassociateThirdPartyFirewallValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDisassociateThirdPartyFirewall(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_opDisassociateThirdPartyFirewall(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "DisassociateThirdPartyFirewall",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns the Organizations account that is associated with Firewall Manager as
// the Firewall Manager default administrator.
func (c *Client) GetAdminAccount(ctx context.Context, params *GetAdminAccountInput, optFns ...func(*Options)) (*GetAdminAccountOutput, error) {
if params == nil {
params = &GetAdminAccountInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetAdminAccount", params, optFns, c.addOperationGetAdminAccountMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetAdminAccountOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetAdminAccountInput struct {
noSmithyDocumentSerde
}
type GetAdminAccountOutput struct {
// The account that is set as the Firewall Manager default administrator.
AdminAccount *string
// The status of the account that you set as the Firewall Manager default
// administrator.
RoleStatus types.AccountRoleStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetAdminAccountMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetAdminAccount{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetAdminAccount{}, 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_opGetAdminAccount(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_opGetAdminAccount(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "GetAdminAccount",
}
}
| 121 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about the specified account's administrative scope. The
// admistrative scope defines the resources that an Firewall Manager administrator
// can manage.
func (c *Client) GetAdminScope(ctx context.Context, params *GetAdminScopeInput, optFns ...func(*Options)) (*GetAdminScopeOutput, error) {
if params == nil {
params = &GetAdminScopeInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetAdminScope", params, optFns, c.addOperationGetAdminScopeMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetAdminScopeOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetAdminScopeInput struct {
// The administator account that you want to get the details for.
//
// This member is required.
AdminAccount *string
noSmithyDocumentSerde
}
type GetAdminScopeOutput struct {
// Contains details about the administrative scope of the requested account.
AdminScope *types.AdminScope
// The current status of the request to onboard a member account as an Firewall
// Manager administator.
// - ONBOARDING - The account is onboarding to Firewall Manager as an
// administrator.
// - ONBOARDING_COMPLETE - Firewall Manager The account is onboarded to Firewall
// Manager as an administrator, and can perform actions on the resources defined in
// their AdminScope .
// - OFFBOARDING - The account is being removed as an Firewall Manager
// administrator.
// - OFFBOARDING_COMPLETE - The account has been removed as an Firewall Manager
// administrator.
Status types.OrganizationStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetAdminScopeMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetAdminScope{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetAdminScope{}, 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 = addOpGetAdminScopeValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetAdminScope(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_opGetAdminScope(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "GetAdminScope",
}
}
| 140 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about the specified Firewall Manager applications list.
func (c *Client) GetAppsList(ctx context.Context, params *GetAppsListInput, optFns ...func(*Options)) (*GetAppsListOutput, error) {
if params == nil {
params = &GetAppsListInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetAppsList", params, optFns, c.addOperationGetAppsListMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetAppsListOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetAppsListInput struct {
// The ID of the Firewall Manager applications list that you want the details for.
//
// This member is required.
ListId *string
// Specifies whether the list to retrieve is a default list owned by Firewall
// Manager.
DefaultList bool
noSmithyDocumentSerde
}
type GetAppsListOutput struct {
// Information about the specified Firewall Manager applications list.
AppsList *types.AppsListData
// The Amazon Resource Name (ARN) of the applications list.
AppsListArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetAppsListMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetAppsList{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetAppsList{}, 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 = addOpGetAppsListValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetAppsList(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_opGetAppsList(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "GetAppsList",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns detailed compliance information about the specified member account.
// Details include resources that are in and out of compliance with the specified
// policy.
// - Resources are considered noncompliant for WAF and Shield Advanced policies
// if the specified policy has not been applied to them.
// - Resources are considered noncompliant for security group policies if they
// are in scope of the policy, they violate one or more of the policy rules, and
// remediation is disabled or not possible.
// - Resources are considered noncompliant for Network Firewall policies if a
// firewall is missing in the VPC, if the firewall endpoint isn't set up in an
// expected Availability Zone and subnet, if a subnet created by the Firewall
// Manager doesn't have the expected route table, and for modifications to a
// firewall policy that violate the Firewall Manager policy's rules.
// - Resources are considered noncompliant for DNS Firewall policies if a DNS
// Firewall rule group is missing from the rule group associations for the VPC.
func (c *Client) GetComplianceDetail(ctx context.Context, params *GetComplianceDetailInput, optFns ...func(*Options)) (*GetComplianceDetailOutput, error) {
if params == nil {
params = &GetComplianceDetailInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetComplianceDetail", params, optFns, c.addOperationGetComplianceDetailMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetComplianceDetailOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetComplianceDetailInput struct {
// The Amazon Web Services account that owns the resources that you want to get
// the details for.
//
// This member is required.
MemberAccount *string
// The ID of the policy that you want to get the details for. PolicyId is returned
// by PutPolicy and by ListPolicies .
//
// This member is required.
PolicyId *string
noSmithyDocumentSerde
}
type GetComplianceDetailOutput struct {
// Information about the resources and the policy that you specified in the
// GetComplianceDetail request.
PolicyComplianceDetail *types.PolicyComplianceDetail
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetComplianceDetailMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetComplianceDetail{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetComplianceDetail{}, 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 = addOpGetComplianceDetailValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetComplianceDetail(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_opGetComplianceDetail(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "GetComplianceDetail",
}
}
| 147 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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"
)
// Information about the Amazon Simple Notification Service (SNS) topic that is
// used to record Firewall Manager SNS logs.
func (c *Client) GetNotificationChannel(ctx context.Context, params *GetNotificationChannelInput, optFns ...func(*Options)) (*GetNotificationChannelOutput, error) {
if params == nil {
params = &GetNotificationChannelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetNotificationChannel", params, optFns, c.addOperationGetNotificationChannelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetNotificationChannelOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetNotificationChannelInput struct {
noSmithyDocumentSerde
}
type GetNotificationChannelOutput struct {
// The IAM role that is used by Firewall Manager to record activity to SNS.
SnsRoleName *string
// The SNS topic that records Firewall Manager activity.
SnsTopicArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetNotificationChannelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetNotificationChannel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetNotificationChannel{}, 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_opGetNotificationChannel(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_opGetNotificationChannel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "GetNotificationChannel",
}
}
| 119 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about the specified Firewall Manager policy.
func (c *Client) GetPolicy(ctx context.Context, params *GetPolicyInput, optFns ...func(*Options)) (*GetPolicyOutput, error) {
if params == nil {
params = &GetPolicyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetPolicy", params, optFns, c.addOperationGetPolicyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetPolicyOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetPolicyInput struct {
// The ID of the Firewall Manager policy that you want the details for.
//
// This member is required.
PolicyId *string
noSmithyDocumentSerde
}
type GetPolicyOutput struct {
// Information about the specified Firewall Manager policy.
Policy *types.Policy
// The Amazon Resource Name (ARN) of the specified policy.
PolicyArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetPolicyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetPolicy{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetPolicy{}, 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 = addOpGetPolicyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetPolicy(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_opGetPolicy(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "GetPolicy",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// If you created a Shield Advanced policy, returns policy-level attack summary
// information in the event of a potential DDoS attack. Other policy types are
// currently unsupported.
func (c *Client) GetProtectionStatus(ctx context.Context, params *GetProtectionStatusInput, optFns ...func(*Options)) (*GetProtectionStatusOutput, error) {
if params == nil {
params = &GetProtectionStatusInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetProtectionStatus", params, optFns, c.addOperationGetProtectionStatusMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetProtectionStatusOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetProtectionStatusInput struct {
// The ID of the policy for which you want to get the attack information.
//
// This member is required.
PolicyId *string
// The end of the time period to query for the attacks. This is a timestamp type.
// The request syntax listing indicates a number type because the default used by
// Firewall Manager is Unix time in seconds. However, any valid timestamp format
// is allowed.
EndTime *time.Time
// Specifies the number of objects that you want Firewall Manager to return for
// this request. If you have more objects than the number that you specify for
// MaxResults , the response includes a NextToken value that you can use to get
// another batch of objects.
MaxResults *int32
// The Amazon Web Services account that is in scope of the policy that you want to
// get the details for.
MemberAccountId *string
// If you specify a value for MaxResults and you have more objects than the number
// that you specify for MaxResults , Firewall Manager returns a NextToken value in
// the response, which you can use to retrieve another group of objects. For the
// second and subsequent GetProtectionStatus requests, specify the value of
// NextToken from the previous response to get information about another batch of
// objects.
NextToken *string
// The start of the time period to query for the attacks. This is a timestamp
// type. The request syntax listing indicates a number type because the default
// used by Firewall Manager is Unix time in seconds. However, any valid timestamp
// format is allowed.
StartTime *time.Time
noSmithyDocumentSerde
}
type GetProtectionStatusOutput struct {
// The ID of the Firewall Manager administrator account for this policy.
AdminAccountId *string
// Details about the attack, including the following:
// - Attack type
// - Account ID
// - ARN of the resource attacked
// - Start time of the attack
// - End time of the attack (ongoing attacks will not have an end time)
// The details are in JSON format.
Data *string
// If you have more objects than the number that you specified for MaxResults in
// the request, the response includes a NextToken value. To list more objects,
// submit another GetProtectionStatus request, and specify the NextToken value
// from the response in the NextToken value in the next request. Amazon Web
// Services SDKs provide auto-pagination that identify NextToken in a response and
// make subsequent request calls automatically on your behalf. However, this
// feature is not supported by GetProtectionStatus . You must submit subsequent
// requests with NextToken using your own processes.
NextToken *string
// The service type that is protected by the policy. Currently, this is always
// SHIELD_ADVANCED .
ServiceType types.SecurityServiceType
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetProtectionStatusMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetProtectionStatus{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetProtectionStatus{}, 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 = addOpGetProtectionStatusValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetProtectionStatus(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_opGetProtectionStatus(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "GetProtectionStatus",
}
}
| 181 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns information about the specified Firewall Manager protocols list.
func (c *Client) GetProtocolsList(ctx context.Context, params *GetProtocolsListInput, optFns ...func(*Options)) (*GetProtocolsListOutput, error) {
if params == nil {
params = &GetProtocolsListInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetProtocolsList", params, optFns, c.addOperationGetProtocolsListMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetProtocolsListOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetProtocolsListInput struct {
// The ID of the Firewall Manager protocols list that you want the details for.
//
// This member is required.
ListId *string
// Specifies whether the list to retrieve is a default list owned by Firewall
// Manager.
DefaultList bool
noSmithyDocumentSerde
}
type GetProtocolsListOutput struct {
// Information about the specified Firewall Manager protocols list.
ProtocolsList *types.ProtocolsListData
// The Amazon Resource Name (ARN) of the specified protocols list.
ProtocolsListArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetProtocolsListMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetProtocolsList{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetProtocolsList{}, 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 = addOpGetProtocolsListValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetProtocolsList(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_opGetProtocolsList(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "GetProtocolsList",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Gets information about a specific resource set.
func (c *Client) GetResourceSet(ctx context.Context, params *GetResourceSetInput, optFns ...func(*Options)) (*GetResourceSetOutput, error) {
if params == nil {
params = &GetResourceSetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetResourceSet", params, optFns, c.addOperationGetResourceSetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetResourceSetOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetResourceSetInput struct {
// A unique identifier for the resource set, used in a request to refer to the
// resource set.
//
// This member is required.
Identifier *string
noSmithyDocumentSerde
}
type GetResourceSetOutput struct {
// Information about the specified resource set.
//
// This member is required.
ResourceSet *types.ResourceSet
// The Amazon Resource Name (ARN) of the resource set.
//
// This member is required.
ResourceSetArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetResourceSetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetResourceSet{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetResourceSet{}, 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 = addOpGetResourceSetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetResourceSet(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_opGetResourceSet(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "GetResourceSet",
}
}
| 133 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// The onboarding status of a Firewall Manager admin account to third-party
// firewall vendor tenant.
func (c *Client) GetThirdPartyFirewallAssociationStatus(ctx context.Context, params *GetThirdPartyFirewallAssociationStatusInput, optFns ...func(*Options)) (*GetThirdPartyFirewallAssociationStatusOutput, error) {
if params == nil {
params = &GetThirdPartyFirewallAssociationStatusInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetThirdPartyFirewallAssociationStatus", params, optFns, c.addOperationGetThirdPartyFirewallAssociationStatusMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetThirdPartyFirewallAssociationStatusOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetThirdPartyFirewallAssociationStatusInput struct {
// The name of the third-party firewall vendor.
//
// This member is required.
ThirdPartyFirewall types.ThirdPartyFirewall
noSmithyDocumentSerde
}
type GetThirdPartyFirewallAssociationStatusOutput struct {
// The status for subscribing to the third-party firewall vendor in the Amazon Web
// Services Marketplace.
// - NO_SUBSCRIPTION - The Firewall Manager policy administrator isn't subscribed
// to the third-party firewall service in the Amazon Web Services Marketplace.
// - NOT_COMPLETE - The Firewall Manager policy administrator is in the process
// of subscribing to the third-party firewall service in the Amazon Web Services
// Marketplace, but doesn't yet have an active subscription.
// - COMPLETE - The Firewall Manager policy administrator has an active
// subscription to the third-party firewall service in the Amazon Web Services
// Marketplace.
MarketplaceOnboardingStatus types.MarketplaceSubscriptionOnboardingStatus
// The current status for setting a Firewall Manager policy administrators account
// as an administrator of the third-party firewall tenant.
// - ONBOARDING - The Firewall Manager policy administrator is being designated
// as a tenant administrator.
// - ONBOARD_COMPLETE - The Firewall Manager policy administrator is designated
// as a tenant administrator.
// - OFFBOARDING - The Firewall Manager policy administrator is being removed as
// a tenant administrator.
// - OFFBOARD_COMPLETE - The Firewall Manager policy administrator has been
// removed as a tenant administrator.
// - NOT_EXIST - The Firewall Manager policy administrator doesn't exist as a
// tenant administrator.
ThirdPartyFirewallStatus types.ThirdPartyFirewallAssociationStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetThirdPartyFirewallAssociationStatusMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetThirdPartyFirewallAssociationStatus{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetThirdPartyFirewallAssociationStatus{}, 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 = addOpGetThirdPartyFirewallAssociationStatusValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetThirdPartyFirewallAssociationStatus(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_opGetThirdPartyFirewallAssociationStatus(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "GetThirdPartyFirewallAssociationStatus",
}
}
| 149 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves violations for a resource based on the specified Firewall Manager
// policy and Amazon Web Services account.
func (c *Client) GetViolationDetails(ctx context.Context, params *GetViolationDetailsInput, optFns ...func(*Options)) (*GetViolationDetailsOutput, error) {
if params == nil {
params = &GetViolationDetailsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetViolationDetails", params, optFns, c.addOperationGetViolationDetailsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetViolationDetailsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetViolationDetailsInput struct {
// The Amazon Web Services account ID that you want the details for.
//
// This member is required.
MemberAccount *string
// The ID of the Firewall Manager policy that you want the details for. This
// currently only supports security group content audit policies.
//
// This member is required.
PolicyId *string
// The ID of the resource that has violations.
//
// This member is required.
ResourceId *string
// The resource type. This is in the format shown in the Amazon Web Services
// Resource Types Reference (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html)
// . Supported resource types are: AWS::EC2::Instance , AWS::EC2::NetworkInterface
// , AWS::EC2::SecurityGroup , AWS::NetworkFirewall::FirewallPolicy , and
// AWS::EC2::Subnet .
//
// This member is required.
ResourceType *string
noSmithyDocumentSerde
}
type GetViolationDetailsOutput struct {
// Violation detail for a resource.
ViolationDetail *types.ViolationDetail
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetViolationDetailsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetViolationDetails{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetViolationDetails{}, 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 = addOpGetViolationDetailsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetViolationDetails(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_opGetViolationDetails(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "GetViolationDetails",
}
}
| 146 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a AdminAccounts object that lists the Firewall Manager administrators
// within the organization that are onboarded to Firewall Manager by
// AssociateAdminAccount . This operation can be called only from the
// organization's management account.
func (c *Client) ListAdminAccountsForOrganization(ctx context.Context, params *ListAdminAccountsForOrganizationInput, optFns ...func(*Options)) (*ListAdminAccountsForOrganizationOutput, error) {
if params == nil {
params = &ListAdminAccountsForOrganizationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListAdminAccountsForOrganization", params, optFns, c.addOperationListAdminAccountsForOrganizationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListAdminAccountsForOrganizationOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListAdminAccountsForOrganizationInput struct {
// The maximum number of objects that you want Firewall Manager to return for this
// request. If more objects are available, in the response, Firewall Manager
// provides a NextToken value that you can use in a subsequent call to get the
// next batch of objects.
MaxResults *int32
// When you request a list of objects with a MaxResults setting, if the number of
// objects that are still available for retrieval exceeds the maximum you
// requested, Firewall Manager returns a NextToken value in the response. To
// retrieve the next batch of objects, use the token returned from the prior
// request in your next request.
NextToken *string
noSmithyDocumentSerde
}
type ListAdminAccountsForOrganizationOutput struct {
// A list of Firewall Manager administrator accounts within the organization that
// were onboarded as administrators by AssociateAdminAccount or PutAdminAccount .
AdminAccounts []types.AdminAccountSummary
// When you request a list of objects with a MaxResults setting, if the number of
// objects that are still available for retrieval exceeds the maximum you
// requested, Firewall Manager returns a NextToken value in the response. To
// retrieve the next batch of objects, use the token returned from the prior
// request in your next request.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListAdminAccountsForOrganizationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListAdminAccountsForOrganization{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListAdminAccountsForOrganization{}, 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_opListAdminAccountsForOrganization(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
}
// ListAdminAccountsForOrganizationAPIClient is a client that implements the
// ListAdminAccountsForOrganization operation.
type ListAdminAccountsForOrganizationAPIClient interface {
ListAdminAccountsForOrganization(context.Context, *ListAdminAccountsForOrganizationInput, ...func(*Options)) (*ListAdminAccountsForOrganizationOutput, error)
}
var _ ListAdminAccountsForOrganizationAPIClient = (*Client)(nil)
// ListAdminAccountsForOrganizationPaginatorOptions is the paginator options for
// ListAdminAccountsForOrganization
type ListAdminAccountsForOrganizationPaginatorOptions struct {
// The maximum number of objects that you want Firewall Manager to return for this
// request. If more objects are available, in the response, Firewall Manager
// provides a NextToken value that you can use in a subsequent call to get the
// next batch of objects.
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
}
// ListAdminAccountsForOrganizationPaginator is a paginator for
// ListAdminAccountsForOrganization
type ListAdminAccountsForOrganizationPaginator struct {
options ListAdminAccountsForOrganizationPaginatorOptions
client ListAdminAccountsForOrganizationAPIClient
params *ListAdminAccountsForOrganizationInput
nextToken *string
firstPage bool
}
// NewListAdminAccountsForOrganizationPaginator returns a new
// ListAdminAccountsForOrganizationPaginator
func NewListAdminAccountsForOrganizationPaginator(client ListAdminAccountsForOrganizationAPIClient, params *ListAdminAccountsForOrganizationInput, optFns ...func(*ListAdminAccountsForOrganizationPaginatorOptions)) *ListAdminAccountsForOrganizationPaginator {
if params == nil {
params = &ListAdminAccountsForOrganizationInput{}
}
options := ListAdminAccountsForOrganizationPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListAdminAccountsForOrganizationPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListAdminAccountsForOrganizationPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListAdminAccountsForOrganization page.
func (p *ListAdminAccountsForOrganizationPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListAdminAccountsForOrganizationOutput, 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.ListAdminAccountsForOrganization(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_opListAdminAccountsForOrganization(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "ListAdminAccountsForOrganization",
}
}
| 238 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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"
)
// Lists the accounts that are managing the specified Organizations member
// account. This is useful for any member account so that they can view the
// accounts who are managing their account. This operation only returns the
// managing administrators that have the requested account within their AdminScope .
func (c *Client) ListAdminsManagingAccount(ctx context.Context, params *ListAdminsManagingAccountInput, optFns ...func(*Options)) (*ListAdminsManagingAccountOutput, error) {
if params == nil {
params = &ListAdminsManagingAccountInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListAdminsManagingAccount", params, optFns, c.addOperationListAdminsManagingAccountMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListAdminsManagingAccountOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListAdminsManagingAccountInput struct {
// The maximum number of objects that you want Firewall Manager to return for this
// request. If more objects are available, in the response, Firewall Manager
// provides a NextToken value that you can use in a subsequent call to get the
// next batch of objects.
MaxResults *int32
// When you request a list of objects with a MaxResults setting, if the number of
// objects that are still available for retrieval exceeds the maximum you
// requested, Firewall Manager returns a NextToken value in the response. To
// retrieve the next batch of objects, use the token returned from the prior
// request in your next request.
NextToken *string
noSmithyDocumentSerde
}
type ListAdminsManagingAccountOutput struct {
// The list of accounts who manage member accounts within their AdminScope .
AdminAccounts []string
// When you request a list of objects with a MaxResults setting, if the number of
// objects that are still available for retrieval exceeds the maximum you
// requested, Firewall Manager returns a NextToken value in the response. To
// retrieve the next batch of objects, use the token returned from the prior
// request in your next request.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListAdminsManagingAccountMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListAdminsManagingAccount{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListAdminsManagingAccount{}, 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_opListAdminsManagingAccount(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
}
// ListAdminsManagingAccountAPIClient is a client that implements the
// ListAdminsManagingAccount operation.
type ListAdminsManagingAccountAPIClient interface {
ListAdminsManagingAccount(context.Context, *ListAdminsManagingAccountInput, ...func(*Options)) (*ListAdminsManagingAccountOutput, error)
}
var _ ListAdminsManagingAccountAPIClient = (*Client)(nil)
// ListAdminsManagingAccountPaginatorOptions is the paginator options for
// ListAdminsManagingAccount
type ListAdminsManagingAccountPaginatorOptions struct {
// The maximum number of objects that you want Firewall Manager to return for this
// request. If more objects are available, in the response, Firewall Manager
// provides a NextToken value that you can use in a subsequent call to get the
// next batch of objects.
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
}
// ListAdminsManagingAccountPaginator is a paginator for ListAdminsManagingAccount
type ListAdminsManagingAccountPaginator struct {
options ListAdminsManagingAccountPaginatorOptions
client ListAdminsManagingAccountAPIClient
params *ListAdminsManagingAccountInput
nextToken *string
firstPage bool
}
// NewListAdminsManagingAccountPaginator returns a new
// ListAdminsManagingAccountPaginator
func NewListAdminsManagingAccountPaginator(client ListAdminsManagingAccountAPIClient, params *ListAdminsManagingAccountInput, optFns ...func(*ListAdminsManagingAccountPaginatorOptions)) *ListAdminsManagingAccountPaginator {
if params == nil {
params = &ListAdminsManagingAccountInput{}
}
options := ListAdminsManagingAccountPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListAdminsManagingAccountPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListAdminsManagingAccountPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListAdminsManagingAccount page.
func (p *ListAdminsManagingAccountPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListAdminsManagingAccountOutput, 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.ListAdminsManagingAccount(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_opListAdminsManagingAccount(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "ListAdminsManagingAccount",
}
}
| 235 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns an array of AppsListDataSummary objects.
func (c *Client) ListAppsLists(ctx context.Context, params *ListAppsListsInput, optFns ...func(*Options)) (*ListAppsListsOutput, error) {
if params == nil {
params = &ListAppsListsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListAppsLists", params, optFns, c.addOperationListAppsListsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListAppsListsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListAppsListsInput struct {
// The maximum number of objects that you want Firewall Manager to return for this
// request. If more objects are available, in the response, Firewall Manager
// provides a NextToken value that you can use in a subsequent call to get the
// next batch of objects. If you don't specify this, Firewall Manager returns all
// available objects.
//
// This member is required.
MaxResults *int32
// Specifies whether the lists to retrieve are default lists owned by Firewall
// Manager.
DefaultLists bool
// If you specify a value for MaxResults in your list request, and you have more
// objects than the maximum, Firewall Manager returns this token in the response.
// For all but the first request, you provide the token returned by the prior
// request in the request parameters, to retrieve the next batch of objects.
NextToken *string
noSmithyDocumentSerde
}
type ListAppsListsOutput struct {
// An array of AppsListDataSummary objects.
AppsLists []types.AppsListDataSummary
// If you specify a value for MaxResults in your list request, and you have more
// objects than the maximum, Firewall Manager returns this token in the response.
// You can use this token in subsequent requests to retrieve the next batch of
// objects.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListAppsListsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListAppsLists{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListAppsLists{}, 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 = addOpListAppsListsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListAppsLists(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
}
// ListAppsListsAPIClient is a client that implements the ListAppsLists operation.
type ListAppsListsAPIClient interface {
ListAppsLists(context.Context, *ListAppsListsInput, ...func(*Options)) (*ListAppsListsOutput, error)
}
var _ ListAppsListsAPIClient = (*Client)(nil)
// ListAppsListsPaginatorOptions is the paginator options for ListAppsLists
type ListAppsListsPaginatorOptions struct {
// The maximum number of objects that you want Firewall Manager to return for this
// request. If more objects are available, in the response, Firewall Manager
// provides a NextToken value that you can use in a subsequent call to get the
// next batch of objects. If you don't specify this, Firewall Manager returns all
// available objects.
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
}
// ListAppsListsPaginator is a paginator for ListAppsLists
type ListAppsListsPaginator struct {
options ListAppsListsPaginatorOptions
client ListAppsListsAPIClient
params *ListAppsListsInput
nextToken *string
firstPage bool
}
// NewListAppsListsPaginator returns a new ListAppsListsPaginator
func NewListAppsListsPaginator(client ListAppsListsAPIClient, params *ListAppsListsInput, optFns ...func(*ListAppsListsPaginatorOptions)) *ListAppsListsPaginator {
if params == nil {
params = &ListAppsListsInput{}
}
options := ListAppsListsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListAppsListsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListAppsListsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListAppsLists page.
func (p *ListAppsListsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListAppsListsOutput, 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.ListAppsLists(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_opListAppsLists(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "ListAppsLists",
}
}
| 239 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns an array of PolicyComplianceStatus objects. Use PolicyComplianceStatus
// to get a summary of which member accounts are protected by the specified policy.
func (c *Client) ListComplianceStatus(ctx context.Context, params *ListComplianceStatusInput, optFns ...func(*Options)) (*ListComplianceStatusOutput, error) {
if params == nil {
params = &ListComplianceStatusInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListComplianceStatus", params, optFns, c.addOperationListComplianceStatusMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListComplianceStatusOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListComplianceStatusInput struct {
// The ID of the Firewall Manager policy that you want the details for.
//
// This member is required.
PolicyId *string
// Specifies the number of PolicyComplianceStatus objects that you want Firewall
// Manager to return for this request. If you have more PolicyComplianceStatus
// objects than the number that you specify for MaxResults , the response includes
// a NextToken value that you can use to get another batch of
// PolicyComplianceStatus objects.
MaxResults *int32
// If you specify a value for MaxResults and you have more PolicyComplianceStatus
// objects than the number that you specify for MaxResults , Firewall Manager
// returns a NextToken value in the response that allows you to list another group
// of PolicyComplianceStatus objects. For the second and subsequent
// ListComplianceStatus requests, specify the value of NextToken from the previous
// response to get information about another batch of PolicyComplianceStatus
// objects.
NextToken *string
noSmithyDocumentSerde
}
type ListComplianceStatusOutput struct {
// If you have more PolicyComplianceStatus objects than the number that you
// specified for MaxResults in the request, the response includes a NextToken
// value. To list more PolicyComplianceStatus objects, submit another
// ListComplianceStatus request, and specify the NextToken value from the response
// in the NextToken value in the next request.
NextToken *string
// An array of PolicyComplianceStatus objects.
PolicyComplianceStatusList []types.PolicyComplianceStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListComplianceStatusMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListComplianceStatus{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListComplianceStatus{}, 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 = addOpListComplianceStatusValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListComplianceStatus(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
}
// ListComplianceStatusAPIClient is a client that implements the
// ListComplianceStatus operation.
type ListComplianceStatusAPIClient interface {
ListComplianceStatus(context.Context, *ListComplianceStatusInput, ...func(*Options)) (*ListComplianceStatusOutput, error)
}
var _ ListComplianceStatusAPIClient = (*Client)(nil)
// ListComplianceStatusPaginatorOptions is the paginator options for
// ListComplianceStatus
type ListComplianceStatusPaginatorOptions struct {
// Specifies the number of PolicyComplianceStatus objects that you want Firewall
// Manager to return for this request. If you have more PolicyComplianceStatus
// objects than the number that you specify for MaxResults , the response includes
// a NextToken value that you can use to get another batch of
// PolicyComplianceStatus objects.
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
}
// ListComplianceStatusPaginator is a paginator for ListComplianceStatus
type ListComplianceStatusPaginator struct {
options ListComplianceStatusPaginatorOptions
client ListComplianceStatusAPIClient
params *ListComplianceStatusInput
nextToken *string
firstPage bool
}
// NewListComplianceStatusPaginator returns a new ListComplianceStatusPaginator
func NewListComplianceStatusPaginator(client ListComplianceStatusAPIClient, params *ListComplianceStatusInput, optFns ...func(*ListComplianceStatusPaginatorOptions)) *ListComplianceStatusPaginator {
if params == nil {
params = &ListComplianceStatusInput{}
}
options := ListComplianceStatusPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListComplianceStatusPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListComplianceStatusPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListComplianceStatus page.
func (p *ListComplianceStatusPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListComplianceStatusOutput, 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.ListComplianceStatus(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_opListComplianceStatus(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "ListComplianceStatus",
}
}
| 245 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns an array of resources in the organization's accounts that are available
// to be associated with a resource set.
func (c *Client) ListDiscoveredResources(ctx context.Context, params *ListDiscoveredResourcesInput, optFns ...func(*Options)) (*ListDiscoveredResourcesOutput, error) {
if params == nil {
params = &ListDiscoveredResourcesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDiscoveredResources", params, optFns, c.addOperationListDiscoveredResourcesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDiscoveredResourcesOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDiscoveredResourcesInput struct {
// The Amazon Web Services account IDs to discover resources in. Only one account
// is supported per request. The account must be a member of your organization.
//
// This member is required.
MemberAccountIds []string
// The type of resources to discover.
//
// This member is required.
ResourceType *string
// The maximum number of objects that you want Firewall Manager to return for this
// request. If more objects are available, in the response, Firewall Manager
// provides a NextToken value that you can use in a subsequent call to get the
// next batch of objects.
MaxResults *int32
// When you request a list of objects with a MaxResults setting, if the number of
// objects that are still available for retrieval exceeds the maximum you
// requested, Firewall Manager returns a NextToken value in the response. To
// retrieve the next batch of objects, use the token returned from the prior
// request in your next request.
NextToken *string
noSmithyDocumentSerde
}
type ListDiscoveredResourcesOutput struct {
// Details of the resources that were discovered.
Items []types.DiscoveredResource
// When you request a list of objects with a MaxResults setting, if the number of
// objects that are still available for retrieval exceeds the maximum you
// requested, Firewall Manager returns a NextToken value in the response. To
// retrieve the next batch of objects, use the token returned from the prior
// request in your next request.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDiscoveredResourcesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListDiscoveredResources{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListDiscoveredResources{}, 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 = addOpListDiscoveredResourcesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListDiscoveredResources(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_opListDiscoveredResources(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "ListDiscoveredResources",
}
}
| 152 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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"
)
// Returns a MemberAccounts object that lists the member accounts in the
// administrator's Amazon Web Services organization. Either an Firewall Manager
// administrator or the organization's management account can make this request.
func (c *Client) ListMemberAccounts(ctx context.Context, params *ListMemberAccountsInput, optFns ...func(*Options)) (*ListMemberAccountsOutput, error) {
if params == nil {
params = &ListMemberAccountsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListMemberAccounts", params, optFns, c.addOperationListMemberAccountsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListMemberAccountsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListMemberAccountsInput struct {
// Specifies the number of member account IDs that you want Firewall Manager to
// return for this request. If you have more IDs than the number that you specify
// for MaxResults , the response includes a NextToken value that you can use to
// get another batch of member account IDs.
MaxResults *int32
// If you specify a value for MaxResults and you have more account IDs than the
// number that you specify for MaxResults , Firewall Manager returns a NextToken
// value in the response that allows you to list another group of IDs. For the
// second and subsequent ListMemberAccountsRequest requests, specify the value of
// NextToken from the previous response to get information about another batch of
// member account IDs.
NextToken *string
noSmithyDocumentSerde
}
type ListMemberAccountsOutput struct {
// An array of account IDs.
MemberAccounts []string
// If you have more member account IDs than the number that you specified for
// MaxResults in the request, the response includes a NextToken value. To list
// more IDs, submit another ListMemberAccounts request, and specify the NextToken
// value from the response in the NextToken value in the next request.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListMemberAccountsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListMemberAccounts{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListMemberAccounts{}, 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_opListMemberAccounts(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
}
// ListMemberAccountsAPIClient is a client that implements the ListMemberAccounts
// operation.
type ListMemberAccountsAPIClient interface {
ListMemberAccounts(context.Context, *ListMemberAccountsInput, ...func(*Options)) (*ListMemberAccountsOutput, error)
}
var _ ListMemberAccountsAPIClient = (*Client)(nil)
// ListMemberAccountsPaginatorOptions is the paginator options for
// ListMemberAccounts
type ListMemberAccountsPaginatorOptions struct {
// Specifies the number of member account IDs that you want Firewall Manager to
// return for this request. If you have more IDs than the number that you specify
// for MaxResults , the response includes a NextToken value that you can use to
// get another batch of member account IDs.
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
}
// ListMemberAccountsPaginator is a paginator for ListMemberAccounts
type ListMemberAccountsPaginator struct {
options ListMemberAccountsPaginatorOptions
client ListMemberAccountsAPIClient
params *ListMemberAccountsInput
nextToken *string
firstPage bool
}
// NewListMemberAccountsPaginator returns a new ListMemberAccountsPaginator
func NewListMemberAccountsPaginator(client ListMemberAccountsAPIClient, params *ListMemberAccountsInput, optFns ...func(*ListMemberAccountsPaginatorOptions)) *ListMemberAccountsPaginator {
if params == nil {
params = &ListMemberAccountsInput{}
}
options := ListMemberAccountsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListMemberAccountsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListMemberAccountsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListMemberAccounts page.
func (p *ListMemberAccountsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListMemberAccountsOutput, 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.ListMemberAccounts(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_opListMemberAccounts(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "ListMemberAccounts",
}
}
| 233 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns an array of PolicySummary objects.
func (c *Client) ListPolicies(ctx context.Context, params *ListPoliciesInput, optFns ...func(*Options)) (*ListPoliciesOutput, error) {
if params == nil {
params = &ListPoliciesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListPolicies", params, optFns, c.addOperationListPoliciesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListPoliciesOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListPoliciesInput struct {
// Specifies the number of PolicySummary objects that you want Firewall Manager to
// return for this request. If you have more PolicySummary objects than the number
// that you specify for MaxResults , the response includes a NextToken value that
// you can use to get another batch of PolicySummary objects.
MaxResults *int32
// If you specify a value for MaxResults and you have more PolicySummary objects
// than the number that you specify for MaxResults , Firewall Manager returns a
// NextToken value in the response that allows you to list another group of
// PolicySummary objects. For the second and subsequent ListPolicies requests,
// specify the value of NextToken from the previous response to get information
// about another batch of PolicySummary objects.
NextToken *string
noSmithyDocumentSerde
}
type ListPoliciesOutput struct {
// If you have more PolicySummary objects than the number that you specified for
// MaxResults in the request, the response includes a NextToken value. To list
// more PolicySummary objects, submit another ListPolicies request, and specify
// the NextToken value from the response in the NextToken value in the next
// request.
NextToken *string
// An array of PolicySummary objects.
PolicyList []types.PolicySummary
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListPoliciesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListPolicies{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListPolicies{}, 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_opListPolicies(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
}
// ListPoliciesAPIClient is a client that implements the ListPolicies operation.
type ListPoliciesAPIClient interface {
ListPolicies(context.Context, *ListPoliciesInput, ...func(*Options)) (*ListPoliciesOutput, error)
}
var _ ListPoliciesAPIClient = (*Client)(nil)
// ListPoliciesPaginatorOptions is the paginator options for ListPolicies
type ListPoliciesPaginatorOptions struct {
// Specifies the number of PolicySummary objects that you want Firewall Manager to
// return for this request. If you have more PolicySummary objects than the number
// that you specify for MaxResults , the response includes a NextToken value that
// you can use to get another batch of PolicySummary objects.
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
}
// ListPoliciesPaginator is a paginator for ListPolicies
type ListPoliciesPaginator struct {
options ListPoliciesPaginatorOptions
client ListPoliciesAPIClient
params *ListPoliciesInput
nextToken *string
firstPage bool
}
// NewListPoliciesPaginator returns a new ListPoliciesPaginator
func NewListPoliciesPaginator(client ListPoliciesAPIClient, params *ListPoliciesInput, optFns ...func(*ListPoliciesPaginatorOptions)) *ListPoliciesPaginator {
if params == nil {
params = &ListPoliciesInput{}
}
options := ListPoliciesPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListPoliciesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListPoliciesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListPolicies page.
func (p *ListPoliciesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListPoliciesOutput, 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.ListPolicies(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_opListPolicies(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "ListPolicies",
}
}
| 231 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns an array of ProtocolsListDataSummary objects.
func (c *Client) ListProtocolsLists(ctx context.Context, params *ListProtocolsListsInput, optFns ...func(*Options)) (*ListProtocolsListsOutput, error) {
if params == nil {
params = &ListProtocolsListsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListProtocolsLists", params, optFns, c.addOperationListProtocolsListsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListProtocolsListsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListProtocolsListsInput struct {
// The maximum number of objects that you want Firewall Manager to return for this
// request. If more objects are available, in the response, Firewall Manager
// provides a NextToken value that you can use in a subsequent call to get the
// next batch of objects. If you don't specify this, Firewall Manager returns all
// available objects.
//
// This member is required.
MaxResults *int32
// Specifies whether the lists to retrieve are default lists owned by Firewall
// Manager.
DefaultLists bool
// If you specify a value for MaxResults in your list request, and you have more
// objects than the maximum, Firewall Manager returns this token in the response.
// For all but the first request, you provide the token returned by the prior
// request in the request parameters, to retrieve the next batch of objects.
NextToken *string
noSmithyDocumentSerde
}
type ListProtocolsListsOutput struct {
// If you specify a value for MaxResults in your list request, and you have more
// objects than the maximum, Firewall Manager returns this token in the response.
// You can use this token in subsequent requests to retrieve the next batch of
// objects.
NextToken *string
// An array of ProtocolsListDataSummary objects.
ProtocolsLists []types.ProtocolsListDataSummary
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListProtocolsListsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListProtocolsLists{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListProtocolsLists{}, 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 = addOpListProtocolsListsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListProtocolsLists(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
}
// ListProtocolsListsAPIClient is a client that implements the ListProtocolsLists
// operation.
type ListProtocolsListsAPIClient interface {
ListProtocolsLists(context.Context, *ListProtocolsListsInput, ...func(*Options)) (*ListProtocolsListsOutput, error)
}
var _ ListProtocolsListsAPIClient = (*Client)(nil)
// ListProtocolsListsPaginatorOptions is the paginator options for
// ListProtocolsLists
type ListProtocolsListsPaginatorOptions struct {
// The maximum number of objects that you want Firewall Manager to return for this
// request. If more objects are available, in the response, Firewall Manager
// provides a NextToken value that you can use in a subsequent call to get the
// next batch of objects. If you don't specify this, Firewall Manager returns all
// available objects.
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
}
// ListProtocolsListsPaginator is a paginator for ListProtocolsLists
type ListProtocolsListsPaginator struct {
options ListProtocolsListsPaginatorOptions
client ListProtocolsListsAPIClient
params *ListProtocolsListsInput
nextToken *string
firstPage bool
}
// NewListProtocolsListsPaginator returns a new ListProtocolsListsPaginator
func NewListProtocolsListsPaginator(client ListProtocolsListsAPIClient, params *ListProtocolsListsInput, optFns ...func(*ListProtocolsListsPaginatorOptions)) *ListProtocolsListsPaginator {
if params == nil {
params = &ListProtocolsListsInput{}
}
options := ListProtocolsListsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListProtocolsListsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListProtocolsListsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListProtocolsLists page.
func (p *ListProtocolsListsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListProtocolsListsOutput, 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.ListProtocolsLists(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_opListProtocolsLists(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "ListProtocolsLists",
}
}
| 241 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns an array of resources that are currently associated to a resource set.
func (c *Client) ListResourceSetResources(ctx context.Context, params *ListResourceSetResourcesInput, optFns ...func(*Options)) (*ListResourceSetResourcesOutput, error) {
if params == nil {
params = &ListResourceSetResourcesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListResourceSetResources", params, optFns, c.addOperationListResourceSetResourcesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListResourceSetResourcesOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListResourceSetResourcesInput struct {
// A unique identifier for the resource set, used in a request to refer to the
// resource set.
//
// This member is required.
Identifier *string
// The maximum number of objects that you want Firewall Manager to return for this
// request. If more objects are available, in the response, Firewall Manager
// provides a NextToken value that you can use in a subsequent call to get the
// next batch of objects.
MaxResults *int32
// When you request a list of objects with a MaxResults setting, if the number of
// objects that are still available for retrieval exceeds the maximum you
// requested, Firewall Manager returns a NextToken value in the response. To
// retrieve the next batch of objects, use the token returned from the prior
// request in your next request.
NextToken *string
noSmithyDocumentSerde
}
type ListResourceSetResourcesOutput struct {
// An array of the associated resources' uniform resource identifiers (URI).
//
// This member is required.
Items []types.Resource
// When you request a list of objects with a MaxResults setting, if the number of
// objects that are still available for retrieval exceeds the maximum you
// requested, Firewall Manager returns a NextToken value in the response. To
// retrieve the next batch of objects, use the token returned from the prior
// request in your next request.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListResourceSetResourcesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListResourceSetResources{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListResourceSetResources{}, 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 = addOpListResourceSetResourcesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListResourceSetResources(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_opListResourceSetResources(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "ListResourceSetResources",
}
}
| 148 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns an array of ResourceSetSummary objects.
func (c *Client) ListResourceSets(ctx context.Context, params *ListResourceSetsInput, optFns ...func(*Options)) (*ListResourceSetsOutput, error) {
if params == nil {
params = &ListResourceSetsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListResourceSets", params, optFns, c.addOperationListResourceSetsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListResourceSetsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListResourceSetsInput struct {
// The maximum number of objects that you want Firewall Manager to return for this
// request. If more objects are available, in the response, Firewall Manager
// provides a NextToken value that you can use in a subsequent call to get the
// next batch of objects.
MaxResults *int32
// When you request a list of objects with a MaxResults setting, if the number of
// objects that are still available for retrieval exceeds the maximum you
// requested, Firewall Manager returns a NextToken value in the response. To
// retrieve the next batch of objects, use the token returned from the prior
// request in your next request.
NextToken *string
noSmithyDocumentSerde
}
type ListResourceSetsOutput struct {
// When you request a list of objects with a MaxResults setting, if the number of
// objects that are still available for retrieval exceeds the maximum you
// requested, Firewall Manager returns a NextToken value in the response. To
// retrieve the next batch of objects, use the token returned from the prior
// request in your next request.
NextToken *string
// An array of ResourceSetSummary objects.
ResourceSets []types.ResourceSetSummary
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListResourceSetsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListResourceSets{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListResourceSets{}, 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_opListResourceSets(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_opListResourceSets(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "ListResourceSets",
}
}
| 137 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves the list of tags for the specified Amazon Web Services resource.
func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error) {
if params == nil {
params = &ListTagsForResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListTagsForResource", params, optFns, c.addOperationListTagsForResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListTagsForResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListTagsForResourceInput struct {
// The Amazon Resource Name (ARN) of the resource to return tags for. The Firewall
// Manager resources that support tagging are policies, applications lists, and
// protocols lists.
//
// This member is required.
ResourceArn *string
noSmithyDocumentSerde
}
type ListTagsForResourceOutput struct {
// The tags associated with the resource.
TagList []types.Tag
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListTagsForResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListTagsForResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_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: "fms",
OperationName: "ListTagsForResource",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves a list of all of the third-party firewall policies that are
// associated with the third-party firewall administrator's account.
func (c *Client) ListThirdPartyFirewallFirewallPolicies(ctx context.Context, params *ListThirdPartyFirewallFirewallPoliciesInput, optFns ...func(*Options)) (*ListThirdPartyFirewallFirewallPoliciesOutput, error) {
if params == nil {
params = &ListThirdPartyFirewallFirewallPoliciesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListThirdPartyFirewallFirewallPolicies", params, optFns, c.addOperationListThirdPartyFirewallFirewallPoliciesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListThirdPartyFirewallFirewallPoliciesOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListThirdPartyFirewallFirewallPoliciesInput struct {
// The maximum number of third-party firewall policies that you want Firewall
// Manager to return. If the specified third-party firewall vendor is associated
// with more than MaxResults firewall policies, the response includes a NextToken
// element. NextToken contains an encrypted token that identifies the first
// third-party firewall policies that Firewall Manager will return if you submit
// another request.
//
// This member is required.
MaxResults *int32
// The name of the third-party firewall vendor.
//
// This member is required.
ThirdPartyFirewall types.ThirdPartyFirewall
// If the previous response included a NextToken element, the specified
// third-party firewall vendor is associated with more third-party firewall
// policies. To get more third-party firewall policies, submit another
// ListThirdPartyFirewallFirewallPoliciesRequest request. For the value of
// NextToken , specify the value of NextToken from the previous response. If the
// previous response didn't include a NextToken element, there are no more
// third-party firewall policies to get.
NextToken *string
noSmithyDocumentSerde
}
type ListThirdPartyFirewallFirewallPoliciesOutput struct {
// The value that you will use for NextToken in the next
// ListThirdPartyFirewallFirewallPolicies request.
NextToken *string
// A list that contains one ThirdPartyFirewallFirewallPolicies element for each
// third-party firewall policies that the specified third-party firewall vendor is
// associated with. Each ThirdPartyFirewallFirewallPolicies element contains the
// firewall policy name and ID.
ThirdPartyFirewallFirewallPolicies []types.ThirdPartyFirewallFirewallPolicy
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListThirdPartyFirewallFirewallPoliciesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListThirdPartyFirewallFirewallPolicies{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListThirdPartyFirewallFirewallPolicies{}, 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 = addOpListThirdPartyFirewallFirewallPoliciesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListThirdPartyFirewallFirewallPolicies(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
}
// ListThirdPartyFirewallFirewallPoliciesAPIClient is a client that implements the
// ListThirdPartyFirewallFirewallPolicies operation.
type ListThirdPartyFirewallFirewallPoliciesAPIClient interface {
ListThirdPartyFirewallFirewallPolicies(context.Context, *ListThirdPartyFirewallFirewallPoliciesInput, ...func(*Options)) (*ListThirdPartyFirewallFirewallPoliciesOutput, error)
}
var _ ListThirdPartyFirewallFirewallPoliciesAPIClient = (*Client)(nil)
// ListThirdPartyFirewallFirewallPoliciesPaginatorOptions is the paginator options
// for ListThirdPartyFirewallFirewallPolicies
type ListThirdPartyFirewallFirewallPoliciesPaginatorOptions struct {
// The maximum number of third-party firewall policies that you want Firewall
// Manager to return. If the specified third-party firewall vendor is associated
// with more than MaxResults firewall policies, the response includes a NextToken
// element. NextToken contains an encrypted token that identifies the first
// third-party firewall policies that Firewall Manager will return if you submit
// another request.
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
}
// ListThirdPartyFirewallFirewallPoliciesPaginator is a paginator for
// ListThirdPartyFirewallFirewallPolicies
type ListThirdPartyFirewallFirewallPoliciesPaginator struct {
options ListThirdPartyFirewallFirewallPoliciesPaginatorOptions
client ListThirdPartyFirewallFirewallPoliciesAPIClient
params *ListThirdPartyFirewallFirewallPoliciesInput
nextToken *string
firstPage bool
}
// NewListThirdPartyFirewallFirewallPoliciesPaginator returns a new
// ListThirdPartyFirewallFirewallPoliciesPaginator
func NewListThirdPartyFirewallFirewallPoliciesPaginator(client ListThirdPartyFirewallFirewallPoliciesAPIClient, params *ListThirdPartyFirewallFirewallPoliciesInput, optFns ...func(*ListThirdPartyFirewallFirewallPoliciesPaginatorOptions)) *ListThirdPartyFirewallFirewallPoliciesPaginator {
if params == nil {
params = &ListThirdPartyFirewallFirewallPoliciesInput{}
}
options := ListThirdPartyFirewallFirewallPoliciesPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListThirdPartyFirewallFirewallPoliciesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListThirdPartyFirewallFirewallPoliciesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListThirdPartyFirewallFirewallPolicies page.
func (p *ListThirdPartyFirewallFirewallPoliciesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListThirdPartyFirewallFirewallPoliciesOutput, 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.ListThirdPartyFirewallFirewallPolicies(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_opListThirdPartyFirewallFirewallPolicies(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "ListThirdPartyFirewallFirewallPolicies",
}
}
| 251 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates or updates an Firewall Manager administrator account. The account must
// be a member of the organization that was onboarded to Firewall Manager by
// AssociateAdminAccount . Only the organization's management account can create an
// Firewall Manager administrator account. When you create an Firewall Manager
// administrator account, the service checks to see if the account is already a
// delegated administrator within Organizations. If the account isn't a delegated
// administrator, Firewall Manager calls Organizations to delegate the account
// within Organizations. For more information about administrator accounts within
// Organizations, see Managing the Amazon Web Services Accounts in Your
// Organization (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_accounts.html)
// .
func (c *Client) PutAdminAccount(ctx context.Context, params *PutAdminAccountInput, optFns ...func(*Options)) (*PutAdminAccountOutput, error) {
if params == nil {
params = &PutAdminAccountInput{}
}
result, metadata, err := c.invokeOperation(ctx, "PutAdminAccount", params, optFns, c.addOperationPutAdminAccountMiddlewares)
if err != nil {
return nil, err
}
out := result.(*PutAdminAccountOutput)
out.ResultMetadata = metadata
return out, nil
}
type PutAdminAccountInput struct {
// The Amazon Web Services account ID to add as an Firewall Manager administrator
// account. The account must be a member of the organization that was onboarded to
// Firewall Manager by AssociateAdminAccount . For more information about
// Organizations, see Managing the Amazon Web Services Accounts in Your
// Organization (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_accounts.html)
// .
//
// This member is required.
AdminAccount *string
// Configures the resources that the specified Firewall Manager administrator can
// manage. As a best practice, set the administrative scope according to the
// principles of least privilege. Only grant the administrator the specific
// resources or permissions that they need to perform the duties of their role.
AdminScope *types.AdminScope
noSmithyDocumentSerde
}
type PutAdminAccountOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationPutAdminAccountMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpPutAdminAccount{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpPutAdminAccount{}, 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 = addOpPutAdminAccountValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutAdminAccount(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_opPutAdminAccount(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "PutAdminAccount",
}
}
| 142 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an Firewall Manager applications list.
func (c *Client) PutAppsList(ctx context.Context, params *PutAppsListInput, optFns ...func(*Options)) (*PutAppsListOutput, error) {
if params == nil {
params = &PutAppsListInput{}
}
result, metadata, err := c.invokeOperation(ctx, "PutAppsList", params, optFns, c.addOperationPutAppsListMiddlewares)
if err != nil {
return nil, err
}
out := result.(*PutAppsListOutput)
out.ResultMetadata = metadata
return out, nil
}
type PutAppsListInput struct {
// The details of the Firewall Manager applications list to be created.
//
// This member is required.
AppsList *types.AppsListData
// The tags associated with the resource.
TagList []types.Tag
noSmithyDocumentSerde
}
type PutAppsListOutput struct {
// The details of the Firewall Manager applications list.
AppsList *types.AppsListData
// The Amazon Resource Name (ARN) of the applications list.
AppsListArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationPutAppsListMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpPutAppsList{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpPutAppsList{}, 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 = addOpPutAppsListValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutAppsList(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_opPutAppsList(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "PutAppsList",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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"
)
// Designates the IAM role and Amazon Simple Notification Service (SNS) topic that
// Firewall Manager uses to record SNS logs. To perform this action outside of the
// console, you must first configure the SNS topic's access policy to allow the
// SnsRoleName to publish SNS logs. If the SnsRoleName provided is a role other
// than the AWSServiceRoleForFMS service-linked role, this role must have a trust
// relationship configured to allow the Firewall Manager service principal
// fms.amazonaws.com to assume this role. For information about configuring an SNS
// access policy, see Service roles for Firewall Manager (https://docs.aws.amazon.com/waf/latest/developerguide/fms-security_iam_service-with-iam.html#fms-security_iam_service-with-iam-roles-service)
// in the Firewall Manager Developer Guide.
func (c *Client) PutNotificationChannel(ctx context.Context, params *PutNotificationChannelInput, optFns ...func(*Options)) (*PutNotificationChannelOutput, error) {
if params == nil {
params = &PutNotificationChannelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "PutNotificationChannel", params, optFns, c.addOperationPutNotificationChannelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*PutNotificationChannelOutput)
out.ResultMetadata = metadata
return out, nil
}
type PutNotificationChannelInput struct {
// The Amazon Resource Name (ARN) of the IAM role that allows Amazon SNS to record
// Firewall Manager activity.
//
// This member is required.
SnsRoleName *string
// The Amazon Resource Name (ARN) of the SNS topic that collects notifications
// from Firewall Manager.
//
// This member is required.
SnsTopicArn *string
noSmithyDocumentSerde
}
type PutNotificationChannelOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationPutNotificationChannelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpPutNotificationChannel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpPutNotificationChannel{}, 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 = addOpPutNotificationChannelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutNotificationChannel(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_opPutNotificationChannel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "PutNotificationChannel",
}
}
| 135 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an Firewall Manager policy. Firewall Manager provides the following
// types of policies:
// - An WAF policy (type WAFV2), which defines rule groups to run first in the
// corresponding WAF web ACL and rule groups to run last in the web ACL.
// - An WAF Classic policy (type WAF), which defines a rule group.
// - A Shield Advanced policy, which applies Shield Advanced protection to
// specified accounts and resources.
// - A security group policy, which manages VPC security groups across your
// Amazon Web Services organization.
// - An Network Firewall policy, which provides firewall rules to filter network
// traffic in specified Amazon VPCs.
// - A DNS Firewall policy, which provides Route 53 Resolver DNS Firewall rules
// to filter DNS queries for specified VPCs.
//
// Each policy is specific to one of the types. If you want to enforce more than
// one policy type across accounts, create multiple policies. You can create
// multiple policies for each type. You must be subscribed to Shield Advanced to
// create a Shield Advanced policy. For more information about subscribing to
// Shield Advanced, see CreateSubscription (https://docs.aws.amazon.com/waf/latest/DDOSAPIReference/API_CreateSubscription.html)
// .
func (c *Client) PutPolicy(ctx context.Context, params *PutPolicyInput, optFns ...func(*Options)) (*PutPolicyOutput, error) {
if params == nil {
params = &PutPolicyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "PutPolicy", params, optFns, c.addOperationPutPolicyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*PutPolicyOutput)
out.ResultMetadata = metadata
return out, nil
}
type PutPolicyInput struct {
// The details of the Firewall Manager policy to be created.
//
// This member is required.
Policy *types.Policy
// The tags to add to the Amazon Web Services resource.
TagList []types.Tag
noSmithyDocumentSerde
}
type PutPolicyOutput struct {
// The details of the Firewall Manager policy.
Policy *types.Policy
// The Amazon Resource Name (ARN) of the policy.
PolicyArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationPutPolicyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpPutPolicy{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpPutPolicy{}, 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 = addOpPutPolicyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutPolicy(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_opPutPolicy(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "PutPolicy",
}
}
| 150 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an Firewall Manager protocols list.
func (c *Client) PutProtocolsList(ctx context.Context, params *PutProtocolsListInput, optFns ...func(*Options)) (*PutProtocolsListOutput, error) {
if params == nil {
params = &PutProtocolsListInput{}
}
result, metadata, err := c.invokeOperation(ctx, "PutProtocolsList", params, optFns, c.addOperationPutProtocolsListMiddlewares)
if err != nil {
return nil, err
}
out := result.(*PutProtocolsListOutput)
out.ResultMetadata = metadata
return out, nil
}
type PutProtocolsListInput struct {
// The details of the Firewall Manager protocols list to be created.
//
// This member is required.
ProtocolsList *types.ProtocolsListData
// The tags associated with the resource.
TagList []types.Tag
noSmithyDocumentSerde
}
type PutProtocolsListOutput struct {
// The details of the Firewall Manager protocols list.
ProtocolsList *types.ProtocolsListData
// The Amazon Resource Name (ARN) of the protocols list.
ProtocolsListArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationPutProtocolsListMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpPutProtocolsList{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpPutProtocolsList{}, 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 = addOpPutProtocolsListValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutProtocolsList(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_opPutProtocolsList(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "PutProtocolsList",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates the resource set. An Firewall Manager resource set defines the
// resources to import into an Firewall Manager policy from another Amazon Web
// Services service.
func (c *Client) PutResourceSet(ctx context.Context, params *PutResourceSetInput, optFns ...func(*Options)) (*PutResourceSetOutput, error) {
if params == nil {
params = &PutResourceSetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "PutResourceSet", params, optFns, c.addOperationPutResourceSetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*PutResourceSetOutput)
out.ResultMetadata = metadata
return out, nil
}
type PutResourceSetInput struct {
// Details about the resource set to be created or updated.>
//
// This member is required.
ResourceSet *types.ResourceSet
// Retrieves the tags associated with the specified resource set. Tags are
// key:value pairs that you can use to categorize and manage your resources, for
// purposes like billing. For example, you might set the tag key to "customer" and
// the value to the customer name or ID. You can specify one or more tags to add to
// each Amazon Web Services resource, up to 50 tags for a resource.
TagList []types.Tag
noSmithyDocumentSerde
}
type PutResourceSetOutput struct {
// Details about the resource set.
//
// This member is required.
ResourceSet *types.ResourceSet
// The Amazon Resource Name (ARN) of the resource set.
//
// This member is required.
ResourceSetArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationPutResourceSetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpPutResourceSet{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpPutResourceSet{}, 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 = addOpPutResourceSetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opPutResourceSet(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_opPutResourceSet(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "PutResourceSet",
}
}
| 141 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Adds one or more tags to an Amazon Web Services 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 return tags for. The Firewall
// Manager resources that support tagging are policies, applications lists, and
// protocols lists.
//
// This member is required.
ResourceArn *string
// The tags to add to the resource.
//
// This member is required.
TagList []types.Tag
noSmithyDocumentSerde
}
type TagResourceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationTagResourceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpTagResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpTagResource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpTagResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opTagResource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opTagResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "TagResource",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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 one or more tags from an Amazon Web Services resource.
func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error) {
if params == nil {
params = &UntagResourceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "UntagResource", params, optFns, c.addOperationUntagResourceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*UntagResourceOutput)
out.ResultMetadata = metadata
return out, nil
}
type UntagResourceInput struct {
// The Amazon Resource Name (ARN) of the resource to return tags for. The Firewall
// Manager resources that support tagging are policies, applications lists, and
// protocols lists.
//
// This member is required.
ResourceArn *string
// The keys of the tags 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(&awsAwsjson11_serializeOpUntagResource{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpUntagResource{}, middleware.After)
if err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = addHTTPSignerV4Middleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpUntagResourceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opUntagResource(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opUntagResource(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "fms",
OperationName: "UntagResource",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
import (
"bytes"
"context"
"encoding/json"
"fmt"
"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
"github.com/aws/aws-sdk-go-v2/service/fms/types"
smithy "github.com/aws/smithy-go"
smithyio "github.com/aws/smithy-go/io"
"github.com/aws/smithy-go/middleware"
"github.com/aws/smithy-go/ptr"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io"
"io/ioutil"
"strings"
)
type awsAwsjson11_deserializeOpAssociateAdminAccount struct {
}
func (*awsAwsjson11_deserializeOpAssociateAdminAccount) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpAssociateAdminAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorAssociateAdminAccount(response, &metadata)
}
output := &AssociateAdminAccountOutput{}
out.Result = output
if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorAssociateAdminAccount(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("LimitExceededException", errorCode):
return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpAssociateThirdPartyFirewall struct {
}
func (*awsAwsjson11_deserializeOpAssociateThirdPartyFirewall) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpAssociateThirdPartyFirewall) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorAssociateThirdPartyFirewall(response, &metadata)
}
output := &AssociateThirdPartyFirewallOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentAssociateThirdPartyFirewallOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorAssociateThirdPartyFirewall(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpBatchAssociateResource struct {
}
func (*awsAwsjson11_deserializeOpBatchAssociateResource) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpBatchAssociateResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorBatchAssociateResource(response, &metadata)
}
output := &BatchAssociateResourceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentBatchAssociateResourceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorBatchAssociateResource(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("LimitExceededException", errorCode):
return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpBatchDisassociateResource struct {
}
func (*awsAwsjson11_deserializeOpBatchDisassociateResource) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpBatchDisassociateResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorBatchDisassociateResource(response, &metadata)
}
output := &BatchDisassociateResourceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentBatchDisassociateResourceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorBatchDisassociateResource(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDeleteAppsList struct {
}
func (*awsAwsjson11_deserializeOpDeleteAppsList) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDeleteAppsList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAppsList(response, &metadata)
}
output := &DeleteAppsListOutput{}
out.Result = output
if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDeleteAppsList(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDeleteNotificationChannel struct {
}
func (*awsAwsjson11_deserializeOpDeleteNotificationChannel) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDeleteNotificationChannel) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorDeleteNotificationChannel(response, &metadata)
}
output := &DeleteNotificationChannelOutput{}
out.Result = output
if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDeleteNotificationChannel(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDeletePolicy struct {
}
func (*awsAwsjson11_deserializeOpDeletePolicy) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDeletePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorDeletePolicy(response, &metadata)
}
output := &DeletePolicyOutput{}
out.Result = output
if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDeletePolicy(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("LimitExceededException", errorCode):
return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDeleteProtocolsList struct {
}
func (*awsAwsjson11_deserializeOpDeleteProtocolsList) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDeleteProtocolsList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorDeleteProtocolsList(response, &metadata)
}
output := &DeleteProtocolsListOutput{}
out.Result = output
if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDeleteProtocolsList(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDeleteResourceSet struct {
}
func (*awsAwsjson11_deserializeOpDeleteResourceSet) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDeleteResourceSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorDeleteResourceSet(response, &metadata)
}
output := &DeleteResourceSetOutput{}
out.Result = output
if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDeleteResourceSet(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDisassociateAdminAccount struct {
}
func (*awsAwsjson11_deserializeOpDisassociateAdminAccount) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDisassociateAdminAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateAdminAccount(response, &metadata)
}
output := &DisassociateAdminAccountOutput{}
out.Result = output
if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDisassociateAdminAccount(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpDisassociateThirdPartyFirewall struct {
}
func (*awsAwsjson11_deserializeOpDisassociateThirdPartyFirewall) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpDisassociateThirdPartyFirewall) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateThirdPartyFirewall(response, &metadata)
}
output := &DisassociateThirdPartyFirewallOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentDisassociateThirdPartyFirewallOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorDisassociateThirdPartyFirewall(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpGetAdminAccount struct {
}
func (*awsAwsjson11_deserializeOpGetAdminAccount) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpGetAdminAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorGetAdminAccount(response, &metadata)
}
output := &GetAdminAccountOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentGetAdminAccountOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorGetAdminAccount(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpGetAdminScope struct {
}
func (*awsAwsjson11_deserializeOpGetAdminScope) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpGetAdminScope) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorGetAdminScope(response, &metadata)
}
output := &GetAdminScopeOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentGetAdminScopeOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorGetAdminScope(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("LimitExceededException", errorCode):
return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpGetAppsList struct {
}
func (*awsAwsjson11_deserializeOpGetAppsList) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpGetAppsList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorGetAppsList(response, &metadata)
}
output := &GetAppsListOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentGetAppsListOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorGetAppsList(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpGetComplianceDetail struct {
}
func (*awsAwsjson11_deserializeOpGetComplianceDetail) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpGetComplianceDetail) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorGetComplianceDetail(response, &metadata)
}
output := &GetComplianceDetailOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentGetComplianceDetailOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorGetComplianceDetail(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpGetNotificationChannel struct {
}
func (*awsAwsjson11_deserializeOpGetNotificationChannel) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpGetNotificationChannel) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorGetNotificationChannel(response, &metadata)
}
output := &GetNotificationChannelOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentGetNotificationChannelOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorGetNotificationChannel(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpGetPolicy struct {
}
func (*awsAwsjson11_deserializeOpGetPolicy) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpGetPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorGetPolicy(response, &metadata)
}
output := &GetPolicyOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentGetPolicyOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorGetPolicy(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("InvalidTypeException", errorCode):
return awsAwsjson11_deserializeErrorInvalidTypeException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpGetProtectionStatus struct {
}
func (*awsAwsjson11_deserializeOpGetProtectionStatus) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpGetProtectionStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorGetProtectionStatus(response, &metadata)
}
output := &GetProtectionStatusOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentGetProtectionStatusOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorGetProtectionStatus(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpGetProtocolsList struct {
}
func (*awsAwsjson11_deserializeOpGetProtocolsList) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpGetProtocolsList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorGetProtocolsList(response, &metadata)
}
output := &GetProtocolsListOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentGetProtocolsListOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorGetProtocolsList(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpGetResourceSet struct {
}
func (*awsAwsjson11_deserializeOpGetResourceSet) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpGetResourceSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorGetResourceSet(response, &metadata)
}
output := &GetResourceSetOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentGetResourceSetOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorGetResourceSet(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpGetThirdPartyFirewallAssociationStatus struct {
}
func (*awsAwsjson11_deserializeOpGetThirdPartyFirewallAssociationStatus) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpGetThirdPartyFirewallAssociationStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorGetThirdPartyFirewallAssociationStatus(response, &metadata)
}
output := &GetThirdPartyFirewallAssociationStatusOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentGetThirdPartyFirewallAssociationStatusOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorGetThirdPartyFirewallAssociationStatus(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpGetViolationDetails struct {
}
func (*awsAwsjson11_deserializeOpGetViolationDetails) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpGetViolationDetails) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorGetViolationDetails(response, &metadata)
}
output := &GetViolationDetailsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentGetViolationDetailsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorGetViolationDetails(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpListAdminAccountsForOrganization struct {
}
func (*awsAwsjson11_deserializeOpListAdminAccountsForOrganization) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpListAdminAccountsForOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorListAdminAccountsForOrganization(response, &metadata)
}
output := &ListAdminAccountsForOrganizationOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentListAdminAccountsForOrganizationOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorListAdminAccountsForOrganization(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("LimitExceededException", errorCode):
return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpListAdminsManagingAccount struct {
}
func (*awsAwsjson11_deserializeOpListAdminsManagingAccount) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpListAdminsManagingAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorListAdminsManagingAccount(response, &metadata)
}
output := &ListAdminsManagingAccountOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentListAdminsManagingAccountOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorListAdminsManagingAccount(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpListAppsLists struct {
}
func (*awsAwsjson11_deserializeOpListAppsLists) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpListAppsLists) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorListAppsLists(response, &metadata)
}
output := &ListAppsListsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentListAppsListsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorListAppsLists(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("LimitExceededException", errorCode):
return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpListComplianceStatus struct {
}
func (*awsAwsjson11_deserializeOpListComplianceStatus) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpListComplianceStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorListComplianceStatus(response, &metadata)
}
output := &ListComplianceStatusOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentListComplianceStatusOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorListComplianceStatus(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpListDiscoveredResources struct {
}
func (*awsAwsjson11_deserializeOpListDiscoveredResources) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpListDiscoveredResources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorListDiscoveredResources(response, &metadata)
}
output := &ListDiscoveredResourcesOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentListDiscoveredResourcesOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorListDiscoveredResources(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpListMemberAccounts struct {
}
func (*awsAwsjson11_deserializeOpListMemberAccounts) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpListMemberAccounts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorListMemberAccounts(response, &metadata)
}
output := &ListMemberAccountsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentListMemberAccountsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorListMemberAccounts(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpListPolicies struct {
}
func (*awsAwsjson11_deserializeOpListPolicies) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpListPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorListPolicies(response, &metadata)
}
output := &ListPoliciesOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentListPoliciesOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorListPolicies(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("LimitExceededException", errorCode):
return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpListProtocolsLists struct {
}
func (*awsAwsjson11_deserializeOpListProtocolsLists) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpListProtocolsLists) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorListProtocolsLists(response, &metadata)
}
output := &ListProtocolsListsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentListProtocolsListsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorListProtocolsLists(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpListResourceSetResources struct {
}
func (*awsAwsjson11_deserializeOpListResourceSetResources) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpListResourceSetResources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorListResourceSetResources(response, &metadata)
}
output := &ListResourceSetResourcesOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentListResourceSetResourcesOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorListResourceSetResources(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpListResourceSets struct {
}
func (*awsAwsjson11_deserializeOpListResourceSets) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpListResourceSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorListResourceSets(response, &metadata)
}
output := &ListResourceSetsOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentListResourceSetsOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorListResourceSets(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpListTagsForResource struct {
}
func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_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, awsAwsjson11_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 = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpListThirdPartyFirewallFirewallPolicies struct {
}
func (*awsAwsjson11_deserializeOpListThirdPartyFirewallFirewallPolicies) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpListThirdPartyFirewallFirewallPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorListThirdPartyFirewallFirewallPolicies(response, &metadata)
}
output := &ListThirdPartyFirewallFirewallPoliciesOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentListThirdPartyFirewallFirewallPoliciesOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorListThirdPartyFirewallFirewallPolicies(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpPutAdminAccount struct {
}
func (*awsAwsjson11_deserializeOpPutAdminAccount) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpPutAdminAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorPutAdminAccount(response, &metadata)
}
output := &PutAdminAccountOutput{}
out.Result = output
if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorPutAdminAccount(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("LimitExceededException", errorCode):
return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpPutAppsList struct {
}
func (*awsAwsjson11_deserializeOpPutAppsList) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpPutAppsList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorPutAppsList(response, &metadata)
}
output := &PutAppsListOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentPutAppsListOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorPutAppsList(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("LimitExceededException", errorCode):
return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpPutNotificationChannel struct {
}
func (*awsAwsjson11_deserializeOpPutNotificationChannel) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpPutNotificationChannel) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorPutNotificationChannel(response, &metadata)
}
output := &PutNotificationChannelOutput{}
out.Result = output
if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorPutNotificationChannel(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpPutPolicy struct {
}
func (*awsAwsjson11_deserializeOpPutPolicy) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpPutPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorPutPolicy(response, &metadata)
}
output := &PutPolicyOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentPutPolicyOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorPutPolicy(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("InvalidTypeException", errorCode):
return awsAwsjson11_deserializeErrorInvalidTypeException(response, errorBody)
case strings.EqualFold("LimitExceededException", errorCode):
return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpPutProtocolsList struct {
}
func (*awsAwsjson11_deserializeOpPutProtocolsList) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpPutProtocolsList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorPutProtocolsList(response, &metadata)
}
output := &PutProtocolsListOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentPutProtocolsListOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorPutProtocolsList(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("LimitExceededException", errorCode):
return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpPutResourceSet struct {
}
func (*awsAwsjson11_deserializeOpPutResourceSet) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpPutResourceSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorPutResourceSet(response, &metadata)
}
output := &PutResourceSetOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentPutResourceSetOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorPutResourceSet(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("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("LimitExceededException", errorCode):
return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpTagResource struct {
}
func (*awsAwsjson11_deserializeOpTagResource) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata)
}
output := &TagResourceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("LimitExceededException", errorCode):
return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
type awsAwsjson11_deserializeOpUntagResource struct {
}
func (*awsAwsjson11_deserializeOpUntagResource) ID() string {
return "OperationDeserializer"
}
func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err != nil {
return out, metadata, err
}
response, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata)
}
output := &UntagResourceOutput{}
out.Result = output
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(response.Body, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return out, metadata, err
}
return out, metadata, err
}
func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
}
errorBody := bytes.NewReader(errorBuffer.Bytes())
errorCode := "UnknownError"
errorMessage := errorCode
headerCode := response.Header.Get("X-Amzn-ErrorType")
if len(headerCode) != 0 {
errorCode = restjson.SanitizeErrorCode(headerCode)
}
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
jsonCode, message, err := restjson.GetErrorInfo(decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
if len(headerCode) == 0 && len(jsonCode) != 0 {
errorCode = restjson.SanitizeErrorCode(jsonCode)
}
if len(message) != 0 {
errorMessage = message
}
switch {
case strings.EqualFold("InternalErrorException", errorCode):
return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody)
case strings.EqualFold("InvalidInputException", errorCode):
return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
case strings.EqualFold("InvalidOperationException", errorCode):
return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody)
case strings.EqualFold("ResourceNotFoundException", errorCode):
return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
default:
genericError := &smithy.GenericAPIError{
Code: errorCode,
Message: errorMessage,
}
return genericError
}
}
func awsAwsjson11_deserializeErrorInternalErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
output := &types.InternalErrorException{}
err := awsAwsjson11_deserializeDocumentInternalErrorException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsAwsjson11_deserializeErrorInvalidInputException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
output := &types.InvalidInputException{}
err := awsAwsjson11_deserializeDocumentInvalidInputException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsAwsjson11_deserializeErrorInvalidOperationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
output := &types.InvalidOperationException{}
err := awsAwsjson11_deserializeDocumentInvalidOperationException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsAwsjson11_deserializeErrorInvalidTypeException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
output := &types.InvalidTypeException{}
err := awsAwsjson11_deserializeDocumentInvalidTypeException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
output := &types.LimitExceededException{}
err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
errorBody.Seek(0, io.SeekStart)
return output
}
func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
var buff [1024]byte
ringBuffer := smithyio.NewRingBuffer(buff[:])
body := io.TeeReader(errorBody, ringBuffer)
decoder := json.NewDecoder(body)
decoder.UseNumber()
var shape interface{}
if err := decoder.Decode(&shape); err != nil && err != io.EOF {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
err = &smithy.DeserializationError{
Err: fmt.Errorf("failed to decode response body, %w", err),
Snapshot: snapshot.Bytes(),
}
return err
}
output := &types.ResourceNotFoundException{}
err := awsAwsjson11_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 awsAwsjson11_deserializeDocumentAccountIdList(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 AWSAccountId to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentAccountScope(v **types.AccountScope, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AccountScope
if *v == nil {
sv = &types.AccountScope{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Accounts":
if err := awsAwsjson11_deserializeDocumentAccountIdList(&sv.Accounts, value); err != nil {
return err
}
case "AllAccountsEnabled":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.AllAccountsEnabled = jtv
}
case "ExcludeSpecifiedAccounts":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.ExcludeSpecifiedAccounts = jtv
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentActionTarget(v **types.ActionTarget, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ActionTarget
if *v == nil {
sv = &types.ActionTarget{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "ResourceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.ResourceId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentAdminAccountSummary(v **types.AdminAccountSummary, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AdminAccountSummary
if *v == nil {
sv = &types.AdminAccountSummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AdminAccount":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AWSAccountId to be of type string, got %T instead", value)
}
sv.AdminAccount = ptr.String(jtv)
}
case "DefaultAdmin":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.DefaultAdmin = jtv
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected OrganizationStatus to be of type string, got %T instead", value)
}
sv.Status = types.OrganizationStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentAdminAccountSummaryList(v *[]types.AdminAccountSummary, 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.AdminAccountSummary
if *v == nil {
cv = []types.AdminAccountSummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.AdminAccountSummary
destAddr := &col
if err := awsAwsjson11_deserializeDocumentAdminAccountSummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentAdminScope(v **types.AdminScope, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AdminScope
if *v == nil {
sv = &types.AdminScope{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AccountScope":
if err := awsAwsjson11_deserializeDocumentAccountScope(&sv.AccountScope, value); err != nil {
return err
}
case "OrganizationalUnitScope":
if err := awsAwsjson11_deserializeDocumentOrganizationalUnitScope(&sv.OrganizationalUnitScope, value); err != nil {
return err
}
case "PolicyTypeScope":
if err := awsAwsjson11_deserializeDocumentPolicyTypeScope(&sv.PolicyTypeScope, value); err != nil {
return err
}
case "RegionScope":
if err := awsAwsjson11_deserializeDocumentRegionScope(&sv.RegionScope, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentApp(v **types.App, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.App
if *v == nil {
sv = &types.App{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AppName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
}
sv.AppName = ptr.String(jtv)
}
case "Port":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected IPPortNumber to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Port = ptr.Int64(i64)
}
case "Protocol":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Protocol to be of type string, got %T instead", value)
}
sv.Protocol = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentAppsList(v *[]types.App, 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.App
if *v == nil {
cv = []types.App{}
} else {
cv = *v
}
for _, value := range shape {
var col types.App
destAddr := &col
if err := awsAwsjson11_deserializeDocumentApp(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentAppsListData(v **types.AppsListData, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AppsListData
if *v == nil {
sv = &types.AppsListData{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AppsList":
if err := awsAwsjson11_deserializeDocumentAppsList(&sv.AppsList, value); err != nil {
return err
}
case "CreateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected TimeStamp to be a JSON Number, got %T instead", value)
}
}
case "LastUpdateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected TimeStamp to be a JSON Number, got %T instead", value)
}
}
case "ListId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ListId to be of type string, got %T instead", value)
}
sv.ListId = ptr.String(jtv)
}
case "ListName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
}
sv.ListName = ptr.String(jtv)
}
case "ListUpdateToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UpdateToken to be of type string, got %T instead", value)
}
sv.ListUpdateToken = ptr.String(jtv)
}
case "PreviousAppsList":
if err := awsAwsjson11_deserializeDocumentPreviousAppsList(&sv.PreviousAppsList, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentAppsListDataSummary(v **types.AppsListDataSummary, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AppsListDataSummary
if *v == nil {
sv = &types.AppsListDataSummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AppsList":
if err := awsAwsjson11_deserializeDocumentAppsList(&sv.AppsList, value); err != nil {
return err
}
case "ListArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
}
sv.ListArn = ptr.String(jtv)
}
case "ListId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ListId to be of type string, got %T instead", value)
}
sv.ListId = ptr.String(jtv)
}
case "ListName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
}
sv.ListName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentAppsListsData(v *[]types.AppsListDataSummary, 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.AppsListDataSummary
if *v == nil {
cv = []types.AppsListDataSummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.AppsListDataSummary
destAddr := &col
if err := awsAwsjson11_deserializeDocumentAppsListDataSummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentAwsEc2InstanceViolation(v **types.AwsEc2InstanceViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AwsEc2InstanceViolation
if *v == nil {
sv = &types.AwsEc2InstanceViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AwsEc2NetworkInterfaceViolations":
if err := awsAwsjson11_deserializeDocumentAwsEc2NetworkInterfaceViolations(&sv.AwsEc2NetworkInterfaceViolations, value); err != nil {
return err
}
case "ViolationTarget":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value)
}
sv.ViolationTarget = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentAwsEc2NetworkInterfaceViolation(v **types.AwsEc2NetworkInterfaceViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AwsEc2NetworkInterfaceViolation
if *v == nil {
sv = &types.AwsEc2NetworkInterfaceViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ViolatingSecurityGroups":
if err := awsAwsjson11_deserializeDocumentResourceIdList(&sv.ViolatingSecurityGroups, value); err != nil {
return err
}
case "ViolationTarget":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value)
}
sv.ViolationTarget = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentAwsEc2NetworkInterfaceViolations(v *[]types.AwsEc2NetworkInterfaceViolation, 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.AwsEc2NetworkInterfaceViolation
if *v == nil {
cv = []types.AwsEc2NetworkInterfaceViolation{}
} else {
cv = *v
}
for _, value := range shape {
var col types.AwsEc2NetworkInterfaceViolation
destAddr := &col
if err := awsAwsjson11_deserializeDocumentAwsEc2NetworkInterfaceViolation(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentAWSRegionList(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 AWSRegion to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentAwsVPCSecurityGroupViolation(v **types.AwsVPCSecurityGroupViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.AwsVPCSecurityGroupViolation
if *v == nil {
sv = &types.AwsVPCSecurityGroupViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "PartialMatches":
if err := awsAwsjson11_deserializeDocumentPartialMatches(&sv.PartialMatches, value); err != nil {
return err
}
case "PossibleSecurityGroupRemediationActions":
if err := awsAwsjson11_deserializeDocumentSecurityGroupRemediationActions(&sv.PossibleSecurityGroupRemediationActions, value); err != nil {
return err
}
case "ViolationTarget":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value)
}
sv.ViolationTarget = ptr.String(jtv)
}
case "ViolationTargetDescription":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.ViolationTargetDescription = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentComplianceViolator(v **types.ComplianceViolator, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ComplianceViolator
if *v == nil {
sv = &types.ComplianceViolator{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Metadata":
if err := awsAwsjson11_deserializeDocumentComplianceViolatorMetadata(&sv.Metadata, value); err != nil {
return err
}
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 "ResourceType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
}
sv.ResourceType = ptr.String(jtv)
}
case "ViolationReason":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ViolationReason to be of type string, got %T instead", value)
}
sv.ViolationReason = types.ViolationReason(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentComplianceViolatorMetadata(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 LengthBoundedString to be of type string, got %T instead", value)
}
parsedVal = jtv
}
mv[key] = parsedVal
}
*v = mv
return nil
}
func awsAwsjson11_deserializeDocumentComplianceViolators(v *[]types.ComplianceViolator, 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.ComplianceViolator
if *v == nil {
cv = []types.ComplianceViolator{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ComplianceViolator
destAddr := &col
if err := awsAwsjson11_deserializeDocumentComplianceViolator(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentCustomerPolicyScopeIdList(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 CustomerPolicyScopeId to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentCustomerPolicyScopeMap(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
mapVar := parsedVal
if err := awsAwsjson11_deserializeDocumentCustomerPolicyScopeIdList(&mapVar, value); err != nil {
return err
}
parsedVal = mapVar
mv[key] = parsedVal
}
*v = mv
return nil
}
func awsAwsjson11_deserializeDocumentDiscoveredResource(v **types.DiscoveredResource, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.DiscoveredResource
if *v == nil {
sv = &types.DiscoveredResource{}
} 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 AWSAccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
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 = ptr.String(jtv)
}
case "URI":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Identifier to be of type string, got %T instead", value)
}
sv.URI = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentDiscoveredResourceList(v *[]types.DiscoveredResource, 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.DiscoveredResource
if *v == nil {
cv = []types.DiscoveredResource{}
} else {
cv = *v
}
for _, value := range shape {
var col types.DiscoveredResource
destAddr := &col
if err := awsAwsjson11_deserializeDocumentDiscoveredResource(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentDnsDuplicateRuleGroupViolation(v **types.DnsDuplicateRuleGroupViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.DnsDuplicateRuleGroupViolation
if *v == nil {
sv = &types.DnsDuplicateRuleGroupViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ViolationTarget":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value)
}
sv.ViolationTarget = ptr.String(jtv)
}
case "ViolationTargetDescription":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.ViolationTargetDescription = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentDnsRuleGroupLimitExceededViolation(v **types.DnsRuleGroupLimitExceededViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.DnsRuleGroupLimitExceededViolation
if *v == nil {
sv = &types.DnsRuleGroupLimitExceededViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "NumberOfRuleGroupsAlreadyAssociated":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected BasicInteger to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.NumberOfRuleGroupsAlreadyAssociated = int32(i64)
}
case "ViolationTarget":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value)
}
sv.ViolationTarget = ptr.String(jtv)
}
case "ViolationTargetDescription":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.ViolationTargetDescription = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentDnsRuleGroupPriorities(v *[]int32, 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 []int32
if *v == nil {
cv = []int32{}
} else {
cv = *v
}
for _, value := range shape {
var col int32
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected DnsRuleGroupPriority to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
col = int32(i64)
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentDnsRuleGroupPriorityConflictViolation(v **types.DnsRuleGroupPriorityConflictViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.DnsRuleGroupPriorityConflictViolation
if *v == nil {
sv = &types.DnsRuleGroupPriorityConflictViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ConflictingPolicyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PolicyId to be of type string, got %T instead", value)
}
sv.ConflictingPolicyId = ptr.String(jtv)
}
case "ConflictingPriority":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected DnsRuleGroupPriority to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.ConflictingPriority = int32(i64)
}
case "UnavailablePriorities":
if err := awsAwsjson11_deserializeDocumentDnsRuleGroupPriorities(&sv.UnavailablePriorities, value); err != nil {
return err
}
case "ViolationTarget":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value)
}
sv.ViolationTarget = ptr.String(jtv)
}
case "ViolationTargetDescription":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.ViolationTargetDescription = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentEC2AssociateRouteTableAction(v **types.EC2AssociateRouteTableAction, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.EC2AssociateRouteTableAction
if *v == nil {
sv = &types.EC2AssociateRouteTableAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "GatewayId":
if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.GatewayId, value); err != nil {
return err
}
case "RouteTableId":
if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.RouteTableId, value); err != nil {
return err
}
case "SubnetId":
if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.SubnetId, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentEC2CopyRouteTableAction(v **types.EC2CopyRouteTableAction, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.EC2CopyRouteTableAction
if *v == nil {
sv = &types.EC2CopyRouteTableAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "RouteTableId":
if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.RouteTableId, value); err != nil {
return err
}
case "VpcId":
if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.VpcId, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentEC2CreateRouteAction(v **types.EC2CreateRouteAction, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.EC2CreateRouteAction
if *v == nil {
sv = &types.EC2CreateRouteAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "DestinationCidrBlock":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CIDR to be of type string, got %T instead", value)
}
sv.DestinationCidrBlock = ptr.String(jtv)
}
case "DestinationIpv6CidrBlock":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CIDR to be of type string, got %T instead", value)
}
sv.DestinationIpv6CidrBlock = ptr.String(jtv)
}
case "DestinationPrefixListId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.DestinationPrefixListId = ptr.String(jtv)
}
case "GatewayId":
if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.GatewayId, value); err != nil {
return err
}
case "RouteTableId":
if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.RouteTableId, value); err != nil {
return err
}
case "VpcEndpointId":
if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.VpcEndpointId, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentEC2CreateRouteTableAction(v **types.EC2CreateRouteTableAction, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.EC2CreateRouteTableAction
if *v == nil {
sv = &types.EC2CreateRouteTableAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "VpcId":
if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.VpcId, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentEC2DeleteRouteAction(v **types.EC2DeleteRouteAction, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.EC2DeleteRouteAction
if *v == nil {
sv = &types.EC2DeleteRouteAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "DestinationCidrBlock":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CIDR to be of type string, got %T instead", value)
}
sv.DestinationCidrBlock = ptr.String(jtv)
}
case "DestinationIpv6CidrBlock":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CIDR to be of type string, got %T instead", value)
}
sv.DestinationIpv6CidrBlock = ptr.String(jtv)
}
case "DestinationPrefixListId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.DestinationPrefixListId = ptr.String(jtv)
}
case "RouteTableId":
if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.RouteTableId, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentEC2ReplaceRouteAction(v **types.EC2ReplaceRouteAction, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.EC2ReplaceRouteAction
if *v == nil {
sv = &types.EC2ReplaceRouteAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "DestinationCidrBlock":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CIDR to be of type string, got %T instead", value)
}
sv.DestinationCidrBlock = ptr.String(jtv)
}
case "DestinationIpv6CidrBlock":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CIDR to be of type string, got %T instead", value)
}
sv.DestinationIpv6CidrBlock = ptr.String(jtv)
}
case "DestinationPrefixListId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.DestinationPrefixListId = ptr.String(jtv)
}
case "GatewayId":
if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.GatewayId, value); err != nil {
return err
}
case "RouteTableId":
if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.RouteTableId, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentEC2ReplaceRouteTableAssociationAction(v **types.EC2ReplaceRouteTableAssociationAction, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.EC2ReplaceRouteTableAssociationAction
if *v == nil {
sv = &types.EC2ReplaceRouteTableAssociationAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AssociationId":
if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.AssociationId, value); err != nil {
return err
}
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "RouteTableId":
if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.RouteTableId, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentEvaluationResult(v **types.EvaluationResult, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.EvaluationResult
if *v == nil {
sv = &types.EvaluationResult{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ComplianceStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PolicyComplianceStatusType to be of type string, got %T instead", value)
}
sv.ComplianceStatus = types.PolicyComplianceStatusType(jtv)
}
case "EvaluationLimitExceeded":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.EvaluationLimitExceeded = jtv
}
case "ViolatorCount":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected ResourceCount to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.ViolatorCount = i64
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentEvaluationResults(v *[]types.EvaluationResult, 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.EvaluationResult
if *v == nil {
cv = []types.EvaluationResult{}
} else {
cv = *v
}
for _, value := range shape {
var col types.EvaluationResult
destAddr := &col
if err := awsAwsjson11_deserializeDocumentEvaluationResult(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentExpectedRoute(v **types.ExpectedRoute, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ExpectedRoute
if *v == nil {
sv = &types.ExpectedRoute{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AllowedTargets":
if err := awsAwsjson11_deserializeDocumentLengthBoundedStringList(&sv.AllowedTargets, value); err != nil {
return err
}
case "ContributingSubnets":
if err := awsAwsjson11_deserializeDocumentResourceIdList(&sv.ContributingSubnets, value); err != nil {
return err
}
case "IpV4Cidr":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CIDR to be of type string, got %T instead", value)
}
sv.IpV4Cidr = ptr.String(jtv)
}
case "IpV6Cidr":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CIDR to be of type string, got %T instead", value)
}
sv.IpV6Cidr = ptr.String(jtv)
}
case "PrefixListId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CIDR to be of type string, got %T instead", value)
}
sv.PrefixListId = ptr.String(jtv)
}
case "RouteTableId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.RouteTableId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentExpectedRoutes(v *[]types.ExpectedRoute, 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.ExpectedRoute
if *v == nil {
cv = []types.ExpectedRoute{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ExpectedRoute
destAddr := &col
if err := awsAwsjson11_deserializeDocumentExpectedRoute(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentFailedItem(v **types.FailedItem, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.FailedItem
if *v == nil {
sv = &types.FailedItem{}
} 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 FailedItemReason to be of type string, got %T instead", value)
}
sv.Reason = types.FailedItemReason(jtv)
}
case "URI":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Identifier to be of type string, got %T instead", value)
}
sv.URI = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentFailedItemList(v *[]types.FailedItem, 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.FailedItem
if *v == nil {
cv = []types.FailedItem{}
} else {
cv = *v
}
for _, value := range shape {
var col types.FailedItem
destAddr := &col
if err := awsAwsjson11_deserializeDocumentFailedItem(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentFirewallSubnetIsOutOfScopeViolation(v **types.FirewallSubnetIsOutOfScopeViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.FirewallSubnetIsOutOfScopeViolation
if *v == nil {
sv = &types.FirewallSubnetIsOutOfScopeViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "FirewallSubnetId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.FirewallSubnetId = ptr.String(jtv)
}
case "SubnetAvailabilityZone":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.SubnetAvailabilityZone = ptr.String(jtv)
}
case "SubnetAvailabilityZoneId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.SubnetAvailabilityZoneId = ptr.String(jtv)
}
case "VpcEndpointId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.VpcEndpointId = ptr.String(jtv)
}
case "VpcId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.VpcId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentFirewallSubnetMissingVPCEndpointViolation(v **types.FirewallSubnetMissingVPCEndpointViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.FirewallSubnetMissingVPCEndpointViolation
if *v == nil {
sv = &types.FirewallSubnetMissingVPCEndpointViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "FirewallSubnetId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.FirewallSubnetId = ptr.String(jtv)
}
case "SubnetAvailabilityZone":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.SubnetAvailabilityZone = ptr.String(jtv)
}
case "SubnetAvailabilityZoneId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.SubnetAvailabilityZoneId = ptr.String(jtv)
}
case "VpcId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.VpcId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentFMSPolicyUpdateFirewallCreationConfigAction(v **types.FMSPolicyUpdateFirewallCreationConfigAction, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.FMSPolicyUpdateFirewallCreationConfigAction
if *v == nil {
sv = &types.FMSPolicyUpdateFirewallCreationConfigAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "FirewallCreationConfig":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ManagedServiceData to be of type string, got %T instead", value)
}
sv.FirewallCreationConfig = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInternalErrorException(v **types.InternalErrorException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.InternalErrorException
if *v == nil {
sv = &types.InternalErrorException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInvalidInputException(v **types.InvalidInputException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.InvalidInputException
if *v == nil {
sv = &types.InvalidInputException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInvalidOperationException(v **types.InvalidOperationException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.InvalidOperationException
if *v == nil {
sv = &types.InvalidOperationException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentInvalidTypeException(v **types.InvalidTypeException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.InvalidTypeException
if *v == nil {
sv = &types.InvalidTypeException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentIssueInfoMap(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 DetailedInfo to be of type string, got %T instead", value)
}
parsedVal = jtv
}
mv[key] = parsedVal
}
*v = mv
return nil
}
func awsAwsjson11_deserializeDocumentLengthBoundedStringList(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 LengthBoundedString to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.LimitExceededException
if *v == nil {
sv = &types.LimitExceededException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentMemberAccounts(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 AWSAccountId to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentNetworkFirewallActionList(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 NetworkFirewallAction to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentNetworkFirewallBlackHoleRouteDetectedViolation(v **types.NetworkFirewallBlackHoleRouteDetectedViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.NetworkFirewallBlackHoleRouteDetectedViolation
if *v == nil {
sv = &types.NetworkFirewallBlackHoleRouteDetectedViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "RouteTableId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.RouteTableId = ptr.String(jtv)
}
case "ViolatingRoutes":
if err := awsAwsjson11_deserializeDocumentRoutes(&sv.ViolatingRoutes, value); err != nil {
return err
}
case "ViolationTarget":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value)
}
sv.ViolationTarget = ptr.String(jtv)
}
case "VpcId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.VpcId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNetworkFirewallInternetTrafficNotInspectedViolation(v **types.NetworkFirewallInternetTrafficNotInspectedViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.NetworkFirewallInternetTrafficNotInspectedViolation
if *v == nil {
sv = &types.NetworkFirewallInternetTrafficNotInspectedViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ActualFirewallSubnetRoutes":
if err := awsAwsjson11_deserializeDocumentRoutes(&sv.ActualFirewallSubnetRoutes, value); err != nil {
return err
}
case "ActualInternetGatewayRoutes":
if err := awsAwsjson11_deserializeDocumentRoutes(&sv.ActualInternetGatewayRoutes, value); err != nil {
return err
}
case "CurrentFirewallSubnetRouteTable":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.CurrentFirewallSubnetRouteTable = ptr.String(jtv)
}
case "CurrentInternetGatewayRouteTable":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.CurrentInternetGatewayRouteTable = ptr.String(jtv)
}
case "ExpectedFirewallEndpoint":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.ExpectedFirewallEndpoint = ptr.String(jtv)
}
case "ExpectedFirewallSubnetRoutes":
if err := awsAwsjson11_deserializeDocumentExpectedRoutes(&sv.ExpectedFirewallSubnetRoutes, value); err != nil {
return err
}
case "ExpectedInternetGatewayRoutes":
if err := awsAwsjson11_deserializeDocumentExpectedRoutes(&sv.ExpectedInternetGatewayRoutes, value); err != nil {
return err
}
case "FirewallSubnetId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.FirewallSubnetId = ptr.String(jtv)
}
case "InternetGatewayId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.InternetGatewayId = ptr.String(jtv)
}
case "IsRouteTableUsedInDifferentAZ":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.IsRouteTableUsedInDifferentAZ = jtv
}
case "RouteTableId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.RouteTableId = ptr.String(jtv)
}
case "SubnetAvailabilityZone":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.SubnetAvailabilityZone = ptr.String(jtv)
}
case "SubnetId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.SubnetId = ptr.String(jtv)
}
case "ViolatingRoutes":
if err := awsAwsjson11_deserializeDocumentRoutes(&sv.ViolatingRoutes, value); err != nil {
return err
}
case "VpcId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.VpcId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNetworkFirewallInvalidRouteConfigurationViolation(v **types.NetworkFirewallInvalidRouteConfigurationViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.NetworkFirewallInvalidRouteConfigurationViolation
if *v == nil {
sv = &types.NetworkFirewallInvalidRouteConfigurationViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ActualFirewallEndpoint":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.ActualFirewallEndpoint = ptr.String(jtv)
}
case "ActualFirewallSubnetId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.ActualFirewallSubnetId = ptr.String(jtv)
}
case "ActualFirewallSubnetRoutes":
if err := awsAwsjson11_deserializeDocumentRoutes(&sv.ActualFirewallSubnetRoutes, value); err != nil {
return err
}
case "ActualInternetGatewayRoutes":
if err := awsAwsjson11_deserializeDocumentRoutes(&sv.ActualInternetGatewayRoutes, value); err != nil {
return err
}
case "AffectedSubnets":
if err := awsAwsjson11_deserializeDocumentResourceIdList(&sv.AffectedSubnets, value); err != nil {
return err
}
case "CurrentFirewallSubnetRouteTable":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.CurrentFirewallSubnetRouteTable = ptr.String(jtv)
}
case "CurrentInternetGatewayRouteTable":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.CurrentInternetGatewayRouteTable = ptr.String(jtv)
}
case "ExpectedFirewallEndpoint":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.ExpectedFirewallEndpoint = ptr.String(jtv)
}
case "ExpectedFirewallSubnetId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.ExpectedFirewallSubnetId = ptr.String(jtv)
}
case "ExpectedFirewallSubnetRoutes":
if err := awsAwsjson11_deserializeDocumentExpectedRoutes(&sv.ExpectedFirewallSubnetRoutes, value); err != nil {
return err
}
case "ExpectedInternetGatewayRoutes":
if err := awsAwsjson11_deserializeDocumentExpectedRoutes(&sv.ExpectedInternetGatewayRoutes, value); err != nil {
return err
}
case "InternetGatewayId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.InternetGatewayId = ptr.String(jtv)
}
case "IsRouteTableUsedInDifferentAZ":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.IsRouteTableUsedInDifferentAZ = jtv
}
case "RouteTableId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.RouteTableId = ptr.String(jtv)
}
case "ViolatingRoute":
if err := awsAwsjson11_deserializeDocumentRoute(&sv.ViolatingRoute, value); err != nil {
return err
}
case "VpcId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.VpcId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNetworkFirewallMissingExpectedRoutesViolation(v **types.NetworkFirewallMissingExpectedRoutesViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.NetworkFirewallMissingExpectedRoutesViolation
if *v == nil {
sv = &types.NetworkFirewallMissingExpectedRoutesViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ExpectedRoutes":
if err := awsAwsjson11_deserializeDocumentExpectedRoutes(&sv.ExpectedRoutes, value); err != nil {
return err
}
case "ViolationTarget":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value)
}
sv.ViolationTarget = ptr.String(jtv)
}
case "VpcId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.VpcId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNetworkFirewallMissingExpectedRTViolation(v **types.NetworkFirewallMissingExpectedRTViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.NetworkFirewallMissingExpectedRTViolation
if *v == nil {
sv = &types.NetworkFirewallMissingExpectedRTViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AvailabilityZone":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.AvailabilityZone = ptr.String(jtv)
}
case "CurrentRouteTable":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.CurrentRouteTable = ptr.String(jtv)
}
case "ExpectedRouteTable":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.ExpectedRouteTable = ptr.String(jtv)
}
case "ViolationTarget":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value)
}
sv.ViolationTarget = ptr.String(jtv)
}
case "VPC":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.VPC = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNetworkFirewallMissingFirewallViolation(v **types.NetworkFirewallMissingFirewallViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.NetworkFirewallMissingFirewallViolation
if *v == nil {
sv = &types.NetworkFirewallMissingFirewallViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AvailabilityZone":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.AvailabilityZone = ptr.String(jtv)
}
case "TargetViolationReason":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TargetViolationReason to be of type string, got %T instead", value)
}
sv.TargetViolationReason = ptr.String(jtv)
}
case "ViolationTarget":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value)
}
sv.ViolationTarget = ptr.String(jtv)
}
case "VPC":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.VPC = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNetworkFirewallMissingSubnetViolation(v **types.NetworkFirewallMissingSubnetViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.NetworkFirewallMissingSubnetViolation
if *v == nil {
sv = &types.NetworkFirewallMissingSubnetViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AvailabilityZone":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.AvailabilityZone = ptr.String(jtv)
}
case "TargetViolationReason":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TargetViolationReason to be of type string, got %T instead", value)
}
sv.TargetViolationReason = ptr.String(jtv)
}
case "ViolationTarget":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value)
}
sv.ViolationTarget = ptr.String(jtv)
}
case "VPC":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.VPC = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNetworkFirewallPolicy(v **types.NetworkFirewallPolicy, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.NetworkFirewallPolicy
if *v == nil {
sv = &types.NetworkFirewallPolicy{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "FirewallDeploymentModel":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FirewallDeploymentModel to be of type string, got %T instead", value)
}
sv.FirewallDeploymentModel = types.FirewallDeploymentModel(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNetworkFirewallPolicyDescription(v **types.NetworkFirewallPolicyDescription, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.NetworkFirewallPolicyDescription
if *v == nil {
sv = &types.NetworkFirewallPolicyDescription{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "StatefulDefaultActions":
if err := awsAwsjson11_deserializeDocumentNetworkFirewallActionList(&sv.StatefulDefaultActions, value); err != nil {
return err
}
case "StatefulEngineOptions":
if err := awsAwsjson11_deserializeDocumentStatefulEngineOptions(&sv.StatefulEngineOptions, value); err != nil {
return err
}
case "StatefulRuleGroups":
if err := awsAwsjson11_deserializeDocumentStatefulRuleGroupList(&sv.StatefulRuleGroups, value); err != nil {
return err
}
case "StatelessCustomActions":
if err := awsAwsjson11_deserializeDocumentNetworkFirewallActionList(&sv.StatelessCustomActions, value); err != nil {
return err
}
case "StatelessDefaultActions":
if err := awsAwsjson11_deserializeDocumentNetworkFirewallActionList(&sv.StatelessDefaultActions, value); err != nil {
return err
}
case "StatelessFragmentDefaultActions":
if err := awsAwsjson11_deserializeDocumentNetworkFirewallActionList(&sv.StatelessFragmentDefaultActions, value); err != nil {
return err
}
case "StatelessRuleGroups":
if err := awsAwsjson11_deserializeDocumentStatelessRuleGroupList(&sv.StatelessRuleGroups, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNetworkFirewallPolicyModifiedViolation(v **types.NetworkFirewallPolicyModifiedViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.NetworkFirewallPolicyModifiedViolation
if *v == nil {
sv = &types.NetworkFirewallPolicyModifiedViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CurrentPolicyDescription":
if err := awsAwsjson11_deserializeDocumentNetworkFirewallPolicyDescription(&sv.CurrentPolicyDescription, value); err != nil {
return err
}
case "ExpectedPolicyDescription":
if err := awsAwsjson11_deserializeDocumentNetworkFirewallPolicyDescription(&sv.ExpectedPolicyDescription, value); err != nil {
return err
}
case "ViolationTarget":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value)
}
sv.ViolationTarget = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNetworkFirewallStatefulRuleGroupOverride(v **types.NetworkFirewallStatefulRuleGroupOverride, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.NetworkFirewallStatefulRuleGroupOverride
if *v == nil {
sv = &types.NetworkFirewallStatefulRuleGroupOverride{}
} 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 NetworkFirewallOverrideAction to be of type string, got %T instead", value)
}
sv.Action = types.NetworkFirewallOverrideAction(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNetworkFirewallUnexpectedFirewallRoutesViolation(v **types.NetworkFirewallUnexpectedFirewallRoutesViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.NetworkFirewallUnexpectedFirewallRoutesViolation
if *v == nil {
sv = &types.NetworkFirewallUnexpectedFirewallRoutesViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "FirewallEndpoint":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.FirewallEndpoint = ptr.String(jtv)
}
case "FirewallSubnetId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.FirewallSubnetId = ptr.String(jtv)
}
case "RouteTableId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.RouteTableId = ptr.String(jtv)
}
case "ViolatingRoutes":
if err := awsAwsjson11_deserializeDocumentRoutes(&sv.ViolatingRoutes, value); err != nil {
return err
}
case "VpcId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.VpcId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentNetworkFirewallUnexpectedGatewayRoutesViolation(v **types.NetworkFirewallUnexpectedGatewayRoutesViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.NetworkFirewallUnexpectedGatewayRoutesViolation
if *v == nil {
sv = &types.NetworkFirewallUnexpectedGatewayRoutesViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "GatewayId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.GatewayId = ptr.String(jtv)
}
case "RouteTableId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.RouteTableId = ptr.String(jtv)
}
case "ViolatingRoutes":
if err := awsAwsjson11_deserializeDocumentRoutes(&sv.ViolatingRoutes, value); err != nil {
return err
}
case "VpcId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.VpcId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentOrderedRemediationActions(v *[]types.RemediationActionWithOrder, 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.RemediationActionWithOrder
if *v == nil {
cv = []types.RemediationActionWithOrder{}
} else {
cv = *v
}
for _, value := range shape {
var col types.RemediationActionWithOrder
destAddr := &col
if err := awsAwsjson11_deserializeDocumentRemediationActionWithOrder(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentOrganizationalUnitIdList(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 OrganizationalUnitId to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentOrganizationalUnitScope(v **types.OrganizationalUnitScope, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.OrganizationalUnitScope
if *v == nil {
sv = &types.OrganizationalUnitScope{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AllOrganizationalUnitsEnabled":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.AllOrganizationalUnitsEnabled = jtv
}
case "ExcludeSpecifiedOrganizationalUnits":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.ExcludeSpecifiedOrganizationalUnits = jtv
}
case "OrganizationalUnits":
if err := awsAwsjson11_deserializeDocumentOrganizationalUnitIdList(&sv.OrganizationalUnits, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentPartialMatch(v **types.PartialMatch, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.PartialMatch
if *v == nil {
sv = &types.PartialMatch{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Reference":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ReferenceRule to be of type string, got %T instead", value)
}
sv.Reference = ptr.String(jtv)
}
case "TargetViolationReasons":
if err := awsAwsjson11_deserializeDocumentTargetViolationReasons(&sv.TargetViolationReasons, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentPartialMatches(v *[]types.PartialMatch, 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.PartialMatch
if *v == nil {
cv = []types.PartialMatch{}
} else {
cv = *v
}
for _, value := range shape {
var col types.PartialMatch
destAddr := &col
if err := awsAwsjson11_deserializeDocumentPartialMatch(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentPolicy(v **types.Policy, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Policy
if *v == nil {
sv = &types.Policy{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "DeleteUnusedFMManagedResources":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.DeleteUnusedFMManagedResources = jtv
}
case "ExcludeMap":
if err := awsAwsjson11_deserializeDocumentCustomerPolicyScopeMap(&sv.ExcludeMap, value); err != nil {
return err
}
case "ExcludeResourceTags":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.ExcludeResourceTags = jtv
}
case "IncludeMap":
if err := awsAwsjson11_deserializeDocumentCustomerPolicyScopeMap(&sv.IncludeMap, value); err != nil {
return err
}
case "PolicyDescription":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceDescription to be of type string, got %T instead", value)
}
sv.PolicyDescription = ptr.String(jtv)
}
case "PolicyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PolicyId to be of type string, got %T instead", value)
}
sv.PolicyId = ptr.String(jtv)
}
case "PolicyName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
}
sv.PolicyName = ptr.String(jtv)
}
case "PolicyStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CustomerPolicyStatus to be of type string, got %T instead", value)
}
sv.PolicyStatus = types.CustomerPolicyStatus(jtv)
}
case "PolicyUpdateToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PolicyUpdateToken to be of type string, got %T instead", value)
}
sv.PolicyUpdateToken = ptr.String(jtv)
}
case "RemediationEnabled":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.RemediationEnabled = jtv
}
case "ResourceSetIds":
if err := awsAwsjson11_deserializeDocumentResourceSetIds(&sv.ResourceSetIds, value); err != nil {
return err
}
case "ResourceTags":
if err := awsAwsjson11_deserializeDocumentResourceTags(&sv.ResourceTags, value); err != nil {
return err
}
case "ResourceType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
}
sv.ResourceType = ptr.String(jtv)
}
case "ResourceTypeList":
if err := awsAwsjson11_deserializeDocumentResourceTypeList(&sv.ResourceTypeList, value); err != nil {
return err
}
case "SecurityServicePolicyData":
if err := awsAwsjson11_deserializeDocumentSecurityServicePolicyData(&sv.SecurityServicePolicyData, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentPolicyComplianceDetail(v **types.PolicyComplianceDetail, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.PolicyComplianceDetail
if *v == nil {
sv = &types.PolicyComplianceDetail{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "EvaluationLimitExceeded":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.EvaluationLimitExceeded = jtv
}
case "ExpiredAt":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.ExpiredAt = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected TimeStamp to be a JSON Number, got %T instead", value)
}
}
case "IssueInfoMap":
if err := awsAwsjson11_deserializeDocumentIssueInfoMap(&sv.IssueInfoMap, value); err != nil {
return err
}
case "MemberAccount":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AWSAccountId to be of type string, got %T instead", value)
}
sv.MemberAccount = ptr.String(jtv)
}
case "PolicyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PolicyId to be of type string, got %T instead", value)
}
sv.PolicyId = ptr.String(jtv)
}
case "PolicyOwner":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AWSAccountId to be of type string, got %T instead", value)
}
sv.PolicyOwner = ptr.String(jtv)
}
case "Violators":
if err := awsAwsjson11_deserializeDocumentComplianceViolators(&sv.Violators, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentPolicyComplianceStatus(v **types.PolicyComplianceStatus, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.PolicyComplianceStatus
if *v == nil {
sv = &types.PolicyComplianceStatus{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "EvaluationResults":
if err := awsAwsjson11_deserializeDocumentEvaluationResults(&sv.EvaluationResults, value); err != nil {
return err
}
case "IssueInfoMap":
if err := awsAwsjson11_deserializeDocumentIssueInfoMap(&sv.IssueInfoMap, value); err != nil {
return err
}
case "LastUpdated":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastUpdated = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected TimeStamp to be a JSON Number, got %T instead", value)
}
}
case "MemberAccount":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AWSAccountId to be of type string, got %T instead", value)
}
sv.MemberAccount = ptr.String(jtv)
}
case "PolicyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PolicyId to be of type string, got %T instead", value)
}
sv.PolicyId = ptr.String(jtv)
}
case "PolicyName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
}
sv.PolicyName = ptr.String(jtv)
}
case "PolicyOwner":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AWSAccountId to be of type string, got %T instead", value)
}
sv.PolicyOwner = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentPolicyComplianceStatusList(v *[]types.PolicyComplianceStatus, 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.PolicyComplianceStatus
if *v == nil {
cv = []types.PolicyComplianceStatus{}
} else {
cv = *v
}
for _, value := range shape {
var col types.PolicyComplianceStatus
destAddr := &col
if err := awsAwsjson11_deserializeDocumentPolicyComplianceStatus(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentPolicyOption(v **types.PolicyOption, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.PolicyOption
if *v == nil {
sv = &types.PolicyOption{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "NetworkFirewallPolicy":
if err := awsAwsjson11_deserializeDocumentNetworkFirewallPolicy(&sv.NetworkFirewallPolicy, value); err != nil {
return err
}
case "ThirdPartyFirewallPolicy":
if err := awsAwsjson11_deserializeDocumentThirdPartyFirewallPolicy(&sv.ThirdPartyFirewallPolicy, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentPolicySummary(v **types.PolicySummary, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.PolicySummary
if *v == nil {
sv = &types.PolicySummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "DeleteUnusedFMManagedResources":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.DeleteUnusedFMManagedResources = jtv
}
case "PolicyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
}
sv.PolicyArn = ptr.String(jtv)
}
case "PolicyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PolicyId to be of type string, got %T instead", value)
}
sv.PolicyId = ptr.String(jtv)
}
case "PolicyName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
}
sv.PolicyName = ptr.String(jtv)
}
case "PolicyStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CustomerPolicyStatus to be of type string, got %T instead", value)
}
sv.PolicyStatus = types.CustomerPolicyStatus(jtv)
}
case "RemediationEnabled":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.RemediationEnabled = jtv
}
case "ResourceType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
}
sv.ResourceType = ptr.String(jtv)
}
case "SecurityServiceType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SecurityServiceType to be of type string, got %T instead", value)
}
sv.SecurityServiceType = types.SecurityServiceType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentPolicySummaryList(v *[]types.PolicySummary, 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.PolicySummary
if *v == nil {
cv = []types.PolicySummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.PolicySummary
destAddr := &col
if err := awsAwsjson11_deserializeDocumentPolicySummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentPolicyTypeScope(v **types.PolicyTypeScope, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.PolicyTypeScope
if *v == nil {
sv = &types.PolicyTypeScope{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AllPolicyTypesEnabled":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.AllPolicyTypesEnabled = jtv
}
case "PolicyTypes":
if err := awsAwsjson11_deserializeDocumentSecurityServiceTypeList(&sv.PolicyTypes, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentPossibleRemediationAction(v **types.PossibleRemediationAction, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.PossibleRemediationAction
if *v == nil {
sv = &types.PossibleRemediationAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "IsDefaultAction":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.IsDefaultAction = jtv
}
case "OrderedRemediationActions":
if err := awsAwsjson11_deserializeDocumentOrderedRemediationActions(&sv.OrderedRemediationActions, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentPossibleRemediationActionList(v *[]types.PossibleRemediationAction, 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.PossibleRemediationAction
if *v == nil {
cv = []types.PossibleRemediationAction{}
} else {
cv = *v
}
for _, value := range shape {
var col types.PossibleRemediationAction
destAddr := &col
if err := awsAwsjson11_deserializeDocumentPossibleRemediationAction(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentPossibleRemediationActions(v **types.PossibleRemediationActions, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.PossibleRemediationActions
if *v == nil {
sv = &types.PossibleRemediationActions{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Actions":
if err := awsAwsjson11_deserializeDocumentPossibleRemediationActionList(&sv.Actions, value); err != nil {
return err
}
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentPreviousAppsList(v *map[string][]types.App, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var mv map[string][]types.App
if *v == nil {
mv = map[string][]types.App{}
} else {
mv = *v
}
for key, value := range shape {
var parsedVal []types.App
mapVar := parsedVal
if err := awsAwsjson11_deserializeDocumentAppsList(&mapVar, value); err != nil {
return err
}
parsedVal = mapVar
mv[key] = parsedVal
}
*v = mv
return nil
}
func awsAwsjson11_deserializeDocumentPreviousProtocolsList(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
mapVar := parsedVal
if err := awsAwsjson11_deserializeDocumentProtocolsList(&mapVar, value); err != nil {
return err
}
parsedVal = mapVar
mv[key] = parsedVal
}
*v = mv
return nil
}
func awsAwsjson11_deserializeDocumentProtocolsList(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 Protocol to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentProtocolsListData(v **types.ProtocolsListData, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ProtocolsListData
if *v == nil {
sv = &types.ProtocolsListData{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CreateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.CreateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected TimeStamp to be a JSON Number, got %T instead", value)
}
}
case "LastUpdateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected TimeStamp to be a JSON Number, got %T instead", value)
}
}
case "ListId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ListId to be of type string, got %T instead", value)
}
sv.ListId = ptr.String(jtv)
}
case "ListName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
}
sv.ListName = ptr.String(jtv)
}
case "ListUpdateToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UpdateToken to be of type string, got %T instead", value)
}
sv.ListUpdateToken = ptr.String(jtv)
}
case "PreviousProtocolsList":
if err := awsAwsjson11_deserializeDocumentPreviousProtocolsList(&sv.PreviousProtocolsList, value); err != nil {
return err
}
case "ProtocolsList":
if err := awsAwsjson11_deserializeDocumentProtocolsList(&sv.ProtocolsList, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentProtocolsListDataSummary(v **types.ProtocolsListDataSummary, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ProtocolsListDataSummary
if *v == nil {
sv = &types.ProtocolsListDataSummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ListArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
}
sv.ListArn = ptr.String(jtv)
}
case "ListId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ListId to be of type string, got %T instead", value)
}
sv.ListId = ptr.String(jtv)
}
case "ListName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value)
}
sv.ListName = ptr.String(jtv)
}
case "ProtocolsList":
if err := awsAwsjson11_deserializeDocumentProtocolsList(&sv.ProtocolsList, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentProtocolsListsData(v *[]types.ProtocolsListDataSummary, 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.ProtocolsListDataSummary
if *v == nil {
cv = []types.ProtocolsListDataSummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ProtocolsListDataSummary
destAddr := &col
if err := awsAwsjson11_deserializeDocumentProtocolsListDataSummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentRegionScope(v **types.RegionScope, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.RegionScope
if *v == nil {
sv = &types.RegionScope{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AllRegionsEnabled":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.AllRegionsEnabled = jtv
}
case "Regions":
if err := awsAwsjson11_deserializeDocumentAWSRegionList(&sv.Regions, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentRemediationAction(v **types.RemediationAction, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.RemediationAction
if *v == nil {
sv = &types.RemediationAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "EC2AssociateRouteTableAction":
if err := awsAwsjson11_deserializeDocumentEC2AssociateRouteTableAction(&sv.EC2AssociateRouteTableAction, value); err != nil {
return err
}
case "EC2CopyRouteTableAction":
if err := awsAwsjson11_deserializeDocumentEC2CopyRouteTableAction(&sv.EC2CopyRouteTableAction, value); err != nil {
return err
}
case "EC2CreateRouteAction":
if err := awsAwsjson11_deserializeDocumentEC2CreateRouteAction(&sv.EC2CreateRouteAction, value); err != nil {
return err
}
case "EC2CreateRouteTableAction":
if err := awsAwsjson11_deserializeDocumentEC2CreateRouteTableAction(&sv.EC2CreateRouteTableAction, value); err != nil {
return err
}
case "EC2DeleteRouteAction":
if err := awsAwsjson11_deserializeDocumentEC2DeleteRouteAction(&sv.EC2DeleteRouteAction, value); err != nil {
return err
}
case "EC2ReplaceRouteAction":
if err := awsAwsjson11_deserializeDocumentEC2ReplaceRouteAction(&sv.EC2ReplaceRouteAction, value); err != nil {
return err
}
case "EC2ReplaceRouteTableAssociationAction":
if err := awsAwsjson11_deserializeDocumentEC2ReplaceRouteTableAssociationAction(&sv.EC2ReplaceRouteTableAssociationAction, value); err != nil {
return err
}
case "FMSPolicyUpdateFirewallCreationConfigAction":
if err := awsAwsjson11_deserializeDocumentFMSPolicyUpdateFirewallCreationConfigAction(&sv.FMSPolicyUpdateFirewallCreationConfigAction, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentRemediationActionWithOrder(v **types.RemediationActionWithOrder, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.RemediationActionWithOrder
if *v == nil {
sv = &types.RemediationActionWithOrder{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Order":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected BasicInteger to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Order = int32(i64)
}
case "RemediationAction":
if err := awsAwsjson11_deserializeDocumentRemediationAction(&sv.RemediationAction, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_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 "AccountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AWSAccountId to be of type string, got %T instead", value)
}
sv.AccountId = ptr.String(jtv)
}
case "URI":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Identifier to be of type string, got %T instead", value)
}
sv.URI = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentResourceIdList(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 ResourceId to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_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 := awsAwsjson11_deserializeDocumentResource(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ResourceNotFoundException
if *v == nil {
sv = &types.ResourceNotFoundException{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Message":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
}
sv.Message = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentResourceSet(v **types.ResourceSet, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ResourceSet
if *v == nil {
sv = &types.ResourceSet{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Description to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "Id":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Base62Id to be of type string, got %T instead", value)
}
sv.Id = ptr.String(jtv)
}
case "LastUpdateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected TimeStamp to be a JSON Number, got %T instead", value)
}
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Name to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "ResourceSetStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceSetStatus to be of type string, got %T instead", value)
}
sv.ResourceSetStatus = types.ResourceSetStatus(jtv)
}
case "ResourceTypeList":
if err := awsAwsjson11_deserializeDocumentResourceTypeList(&sv.ResourceTypeList, value); err != nil {
return err
}
case "UpdateToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected UpdateToken to be of type string, got %T instead", value)
}
sv.UpdateToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentResourceSetIds(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 Base62Id to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentResourceSetSummary(v **types.ResourceSetSummary, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ResourceSetSummary
if *v == nil {
sv = &types.ResourceSetSummary{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Description to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "Id":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Base62Id to be of type string, got %T instead", value)
}
sv.Id = ptr.String(jtv)
}
case "LastUpdateTime":
if value != nil {
switch jtv := value.(type) {
case json.Number:
f64, err := jtv.Float64()
if err != nil {
return err
}
sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
default:
return fmt.Errorf("expected TimeStamp to be a JSON Number, got %T instead", value)
}
}
case "Name":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Name to be of type string, got %T instead", value)
}
sv.Name = ptr.String(jtv)
}
case "ResourceSetStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceSetStatus to be of type string, got %T instead", value)
}
sv.ResourceSetStatus = types.ResourceSetStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentResourceSetSummaryList(v *[]types.ResourceSetSummary, 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.ResourceSetSummary
if *v == nil {
cv = []types.ResourceSetSummary{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ResourceSetSummary
destAddr := &col
if err := awsAwsjson11_deserializeDocumentResourceSetSummary(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentResourceTag(v **types.ResourceTag, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ResourceTag
if *v == nil {
sv = &types.ResourceTag{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Key":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceTagKey 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 ResourceTagValue to be of type string, got %T instead", value)
}
sv.Value = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentResourceTags(v *[]types.ResourceTag, 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.ResourceTag
if *v == nil {
cv = []types.ResourceTag{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ResourceTag
destAddr := &col
if err := awsAwsjson11_deserializeDocumentResourceTag(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentResourceTypeList(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 ResourceType to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentResourceViolation(v **types.ResourceViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ResourceViolation
if *v == nil {
sv = &types.ResourceViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AwsEc2InstanceViolation":
if err := awsAwsjson11_deserializeDocumentAwsEc2InstanceViolation(&sv.AwsEc2InstanceViolation, value); err != nil {
return err
}
case "AwsEc2NetworkInterfaceViolation":
if err := awsAwsjson11_deserializeDocumentAwsEc2NetworkInterfaceViolation(&sv.AwsEc2NetworkInterfaceViolation, value); err != nil {
return err
}
case "AwsVPCSecurityGroupViolation":
if err := awsAwsjson11_deserializeDocumentAwsVPCSecurityGroupViolation(&sv.AwsVPCSecurityGroupViolation, value); err != nil {
return err
}
case "DnsDuplicateRuleGroupViolation":
if err := awsAwsjson11_deserializeDocumentDnsDuplicateRuleGroupViolation(&sv.DnsDuplicateRuleGroupViolation, value); err != nil {
return err
}
case "DnsRuleGroupLimitExceededViolation":
if err := awsAwsjson11_deserializeDocumentDnsRuleGroupLimitExceededViolation(&sv.DnsRuleGroupLimitExceededViolation, value); err != nil {
return err
}
case "DnsRuleGroupPriorityConflictViolation":
if err := awsAwsjson11_deserializeDocumentDnsRuleGroupPriorityConflictViolation(&sv.DnsRuleGroupPriorityConflictViolation, value); err != nil {
return err
}
case "FirewallSubnetIsOutOfScopeViolation":
if err := awsAwsjson11_deserializeDocumentFirewallSubnetIsOutOfScopeViolation(&sv.FirewallSubnetIsOutOfScopeViolation, value); err != nil {
return err
}
case "FirewallSubnetMissingVPCEndpointViolation":
if err := awsAwsjson11_deserializeDocumentFirewallSubnetMissingVPCEndpointViolation(&sv.FirewallSubnetMissingVPCEndpointViolation, value); err != nil {
return err
}
case "NetworkFirewallBlackHoleRouteDetectedViolation":
if err := awsAwsjson11_deserializeDocumentNetworkFirewallBlackHoleRouteDetectedViolation(&sv.NetworkFirewallBlackHoleRouteDetectedViolation, value); err != nil {
return err
}
case "NetworkFirewallInternetTrafficNotInspectedViolation":
if err := awsAwsjson11_deserializeDocumentNetworkFirewallInternetTrafficNotInspectedViolation(&sv.NetworkFirewallInternetTrafficNotInspectedViolation, value); err != nil {
return err
}
case "NetworkFirewallInvalidRouteConfigurationViolation":
if err := awsAwsjson11_deserializeDocumentNetworkFirewallInvalidRouteConfigurationViolation(&sv.NetworkFirewallInvalidRouteConfigurationViolation, value); err != nil {
return err
}
case "NetworkFirewallMissingExpectedRoutesViolation":
if err := awsAwsjson11_deserializeDocumentNetworkFirewallMissingExpectedRoutesViolation(&sv.NetworkFirewallMissingExpectedRoutesViolation, value); err != nil {
return err
}
case "NetworkFirewallMissingExpectedRTViolation":
if err := awsAwsjson11_deserializeDocumentNetworkFirewallMissingExpectedRTViolation(&sv.NetworkFirewallMissingExpectedRTViolation, value); err != nil {
return err
}
case "NetworkFirewallMissingFirewallViolation":
if err := awsAwsjson11_deserializeDocumentNetworkFirewallMissingFirewallViolation(&sv.NetworkFirewallMissingFirewallViolation, value); err != nil {
return err
}
case "NetworkFirewallMissingSubnetViolation":
if err := awsAwsjson11_deserializeDocumentNetworkFirewallMissingSubnetViolation(&sv.NetworkFirewallMissingSubnetViolation, value); err != nil {
return err
}
case "NetworkFirewallPolicyModifiedViolation":
if err := awsAwsjson11_deserializeDocumentNetworkFirewallPolicyModifiedViolation(&sv.NetworkFirewallPolicyModifiedViolation, value); err != nil {
return err
}
case "NetworkFirewallUnexpectedFirewallRoutesViolation":
if err := awsAwsjson11_deserializeDocumentNetworkFirewallUnexpectedFirewallRoutesViolation(&sv.NetworkFirewallUnexpectedFirewallRoutesViolation, value); err != nil {
return err
}
case "NetworkFirewallUnexpectedGatewayRoutesViolation":
if err := awsAwsjson11_deserializeDocumentNetworkFirewallUnexpectedGatewayRoutesViolation(&sv.NetworkFirewallUnexpectedGatewayRoutesViolation, value); err != nil {
return err
}
case "PossibleRemediationActions":
if err := awsAwsjson11_deserializeDocumentPossibleRemediationActions(&sv.PossibleRemediationActions, value); err != nil {
return err
}
case "RouteHasOutOfScopeEndpointViolation":
if err := awsAwsjson11_deserializeDocumentRouteHasOutOfScopeEndpointViolation(&sv.RouteHasOutOfScopeEndpointViolation, value); err != nil {
return err
}
case "ThirdPartyFirewallMissingExpectedRouteTableViolation":
if err := awsAwsjson11_deserializeDocumentThirdPartyFirewallMissingExpectedRouteTableViolation(&sv.ThirdPartyFirewallMissingExpectedRouteTableViolation, value); err != nil {
return err
}
case "ThirdPartyFirewallMissingFirewallViolation":
if err := awsAwsjson11_deserializeDocumentThirdPartyFirewallMissingFirewallViolation(&sv.ThirdPartyFirewallMissingFirewallViolation, value); err != nil {
return err
}
case "ThirdPartyFirewallMissingSubnetViolation":
if err := awsAwsjson11_deserializeDocumentThirdPartyFirewallMissingSubnetViolation(&sv.ThirdPartyFirewallMissingSubnetViolation, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentResourceViolations(v *[]types.ResourceViolation, 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.ResourceViolation
if *v == nil {
cv = []types.ResourceViolation{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ResourceViolation
destAddr := &col
if err := awsAwsjson11_deserializeDocumentResourceViolation(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentRoute(v **types.Route, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Route
if *v == nil {
sv = &types.Route{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Destination":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.Destination = ptr.String(jtv)
}
case "DestinationType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected DestinationType to be of type string, got %T instead", value)
}
sv.DestinationType = types.DestinationType(jtv)
}
case "Target":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.Target = ptr.String(jtv)
}
case "TargetType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TargetType to be of type string, got %T instead", value)
}
sv.TargetType = types.TargetType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentRouteHasOutOfScopeEndpointViolation(v **types.RouteHasOutOfScopeEndpointViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.RouteHasOutOfScopeEndpointViolation
if *v == nil {
sv = &types.RouteHasOutOfScopeEndpointViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "CurrentFirewallSubnetRouteTable":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.CurrentFirewallSubnetRouteTable = ptr.String(jtv)
}
case "CurrentInternetGatewayRouteTable":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.CurrentInternetGatewayRouteTable = ptr.String(jtv)
}
case "FirewallSubnetId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.FirewallSubnetId = ptr.String(jtv)
}
case "FirewallSubnetRoutes":
if err := awsAwsjson11_deserializeDocumentRoutes(&sv.FirewallSubnetRoutes, value); err != nil {
return err
}
case "InternetGatewayId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.InternetGatewayId = ptr.String(jtv)
}
case "InternetGatewayRoutes":
if err := awsAwsjson11_deserializeDocumentRoutes(&sv.InternetGatewayRoutes, value); err != nil {
return err
}
case "RouteTableId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.RouteTableId = ptr.String(jtv)
}
case "SubnetAvailabilityZone":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.SubnetAvailabilityZone = ptr.String(jtv)
}
case "SubnetAvailabilityZoneId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.SubnetAvailabilityZoneId = ptr.String(jtv)
}
case "SubnetId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.SubnetId = ptr.String(jtv)
}
case "ViolatingRoutes":
if err := awsAwsjson11_deserializeDocumentRoutes(&sv.ViolatingRoutes, value); err != nil {
return err
}
case "VpcId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.VpcId = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentRoutes(v *[]types.Route, 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.Route
if *v == nil {
cv = []types.Route{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Route
destAddr := &col
if err := awsAwsjson11_deserializeDocumentRoute(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentSecurityGroupRemediationAction(v **types.SecurityGroupRemediationAction, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.SecurityGroupRemediationAction
if *v == nil {
sv = &types.SecurityGroupRemediationAction{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Description":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected RemediationActionDescription to be of type string, got %T instead", value)
}
sv.Description = ptr.String(jtv)
}
case "IsDefaultAction":
if value != nil {
jtv, ok := value.(bool)
if !ok {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
}
sv.IsDefaultAction = jtv
}
case "RemediationActionType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected RemediationActionType to be of type string, got %T instead", value)
}
sv.RemediationActionType = types.RemediationActionType(jtv)
}
case "RemediationResult":
if err := awsAwsjson11_deserializeDocumentSecurityGroupRuleDescription(&sv.RemediationResult, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentSecurityGroupRemediationActions(v *[]types.SecurityGroupRemediationAction, 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.SecurityGroupRemediationAction
if *v == nil {
cv = []types.SecurityGroupRemediationAction{}
} else {
cv = *v
}
for _, value := range shape {
var col types.SecurityGroupRemediationAction
destAddr := &col
if err := awsAwsjson11_deserializeDocumentSecurityGroupRemediationAction(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentSecurityGroupRuleDescription(v **types.SecurityGroupRuleDescription, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.SecurityGroupRuleDescription
if *v == nil {
sv = &types.SecurityGroupRuleDescription{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "FromPort":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected IPPortNumber to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.FromPort = ptr.Int64(i64)
}
case "IPV4Range":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CIDR to be of type string, got %T instead", value)
}
sv.IPV4Range = ptr.String(jtv)
}
case "IPV6Range":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected CIDR to be of type string, got %T instead", value)
}
sv.IPV6Range = ptr.String(jtv)
}
case "PrefixListId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.PrefixListId = ptr.String(jtv)
}
case "Protocol":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.Protocol = ptr.String(jtv)
}
case "ToPort":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected IPPortNumber to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.ToPort = ptr.Int64(i64)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentSecurityServicePolicyData(v **types.SecurityServicePolicyData, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.SecurityServicePolicyData
if *v == nil {
sv = &types.SecurityServicePolicyData{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ManagedServiceData":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ManagedServiceData to be of type string, got %T instead", value)
}
sv.ManagedServiceData = ptr.String(jtv)
}
case "PolicyOption":
if err := awsAwsjson11_deserializeDocumentPolicyOption(&sv.PolicyOption, value); err != nil {
return err
}
case "Type":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SecurityServiceType to be of type string, got %T instead", value)
}
sv.Type = types.SecurityServiceType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentSecurityServiceTypeList(v *[]types.SecurityServiceType, 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.SecurityServiceType
if *v == nil {
cv = []types.SecurityServiceType{}
} else {
cv = *v
}
for _, value := range shape {
var col types.SecurityServiceType
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SecurityServiceType to be of type string, got %T instead", value)
}
col = types.SecurityServiceType(jtv)
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentStatefulEngineOptions(v **types.StatefulEngineOptions, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.StatefulEngineOptions
if *v == nil {
sv = &types.StatefulEngineOptions{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "RuleOrder":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected RuleOrder to be of type string, got %T instead", value)
}
sv.RuleOrder = types.RuleOrder(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentStatefulRuleGroup(v **types.StatefulRuleGroup, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.StatefulRuleGroup
if *v == nil {
sv = &types.StatefulRuleGroup{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Override":
if err := awsAwsjson11_deserializeDocumentNetworkFirewallStatefulRuleGroupOverride(&sv.Override, value); err != nil {
return err
}
case "Priority":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected PriorityNumber to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Priority = ptr.Int32(int32(i64))
}
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 "RuleGroupName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NetworkFirewallResourceName to be of type string, got %T instead", value)
}
sv.RuleGroupName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentStatefulRuleGroupList(v *[]types.StatefulRuleGroup, 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.StatefulRuleGroup
if *v == nil {
cv = []types.StatefulRuleGroup{}
} else {
cv = *v
}
for _, value := range shape {
var col types.StatefulRuleGroup
destAddr := &col
if err := awsAwsjson11_deserializeDocumentStatefulRuleGroup(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentStatelessRuleGroup(v **types.StatelessRuleGroup, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.StatelessRuleGroup
if *v == nil {
sv = &types.StatelessRuleGroup{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Priority":
if value != nil {
jtv, ok := value.(json.Number)
if !ok {
return fmt.Errorf("expected StatelessRuleGroupPriority to be json.Number, got %T instead", value)
}
i64, err := jtv.Int64()
if err != nil {
return err
}
sv.Priority = int32(i64)
}
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 "RuleGroupName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected NetworkFirewallResourceName to be of type string, got %T instead", value)
}
sv.RuleGroupName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentStatelessRuleGroupList(v *[]types.StatelessRuleGroup, 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.StatelessRuleGroup
if *v == nil {
cv = []types.StatelessRuleGroup{}
} else {
cv = *v
}
for _, value := range shape {
var col types.StatelessRuleGroup
destAddr := &col
if err := awsAwsjson11_deserializeDocumentStatelessRuleGroup(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.Tag
if *v == nil {
sv = &types.Tag{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Key":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TagKey to be of type string, got %T instead", value)
}
sv.Key = ptr.String(jtv)
}
case "Value":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TagValue to be of type string, got %T instead", value)
}
sv.Value = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.([]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var cv []types.Tag
if *v == nil {
cv = []types.Tag{}
} else {
cv = *v
}
for _, value := range shape {
var col types.Tag
destAddr := &col
if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentTargetViolationReasons(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 TargetViolationReason to be of type string, got %T instead", value)
}
col = jtv
}
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentThirdPartyFirewallFirewallPolicies(v *[]types.ThirdPartyFirewallFirewallPolicy, 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.ThirdPartyFirewallFirewallPolicy
if *v == nil {
cv = []types.ThirdPartyFirewallFirewallPolicy{}
} else {
cv = *v
}
for _, value := range shape {
var col types.ThirdPartyFirewallFirewallPolicy
destAddr := &col
if err := awsAwsjson11_deserializeDocumentThirdPartyFirewallFirewallPolicy(&destAddr, value); err != nil {
return err
}
col = *destAddr
cv = append(cv, col)
}
*v = cv
return nil
}
func awsAwsjson11_deserializeDocumentThirdPartyFirewallFirewallPolicy(v **types.ThirdPartyFirewallFirewallPolicy, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ThirdPartyFirewallFirewallPolicy
if *v == nil {
sv = &types.ThirdPartyFirewallFirewallPolicy{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "FirewallPolicyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FirewallPolicyId to be of type string, got %T instead", value)
}
sv.FirewallPolicyId = ptr.String(jtv)
}
case "FirewallPolicyName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FirewallPolicyName to be of type string, got %T instead", value)
}
sv.FirewallPolicyName = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentThirdPartyFirewallMissingExpectedRouteTableViolation(v **types.ThirdPartyFirewallMissingExpectedRouteTableViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ThirdPartyFirewallMissingExpectedRouteTableViolation
if *v == nil {
sv = &types.ThirdPartyFirewallMissingExpectedRouteTableViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AvailabilityZone":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.AvailabilityZone = ptr.String(jtv)
}
case "CurrentRouteTable":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.CurrentRouteTable = ptr.String(jtv)
}
case "ExpectedRouteTable":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.ExpectedRouteTable = ptr.String(jtv)
}
case "ViolationTarget":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value)
}
sv.ViolationTarget = ptr.String(jtv)
}
case "VPC":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.VPC = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentThirdPartyFirewallMissingFirewallViolation(v **types.ThirdPartyFirewallMissingFirewallViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ThirdPartyFirewallMissingFirewallViolation
if *v == nil {
sv = &types.ThirdPartyFirewallMissingFirewallViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AvailabilityZone":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.AvailabilityZone = ptr.String(jtv)
}
case "TargetViolationReason":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TargetViolationReason to be of type string, got %T instead", value)
}
sv.TargetViolationReason = ptr.String(jtv)
}
case "ViolationTarget":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value)
}
sv.ViolationTarget = ptr.String(jtv)
}
case "VPC":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.VPC = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentThirdPartyFirewallMissingSubnetViolation(v **types.ThirdPartyFirewallMissingSubnetViolation, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ThirdPartyFirewallMissingSubnetViolation
if *v == nil {
sv = &types.ThirdPartyFirewallMissingSubnetViolation{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AvailabilityZone":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.AvailabilityZone = ptr.String(jtv)
}
case "TargetViolationReason":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected TargetViolationReason to be of type string, got %T instead", value)
}
sv.TargetViolationReason = ptr.String(jtv)
}
case "ViolationTarget":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value)
}
sv.ViolationTarget = ptr.String(jtv)
}
case "VPC":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.VPC = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentThirdPartyFirewallPolicy(v **types.ThirdPartyFirewallPolicy, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ThirdPartyFirewallPolicy
if *v == nil {
sv = &types.ThirdPartyFirewallPolicy{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "FirewallDeploymentModel":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected FirewallDeploymentModel to be of type string, got %T instead", value)
}
sv.FirewallDeploymentModel = types.FirewallDeploymentModel(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeDocumentViolationDetail(v **types.ViolationDetail, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *types.ViolationDetail
if *v == nil {
sv = &types.ViolationDetail{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "MemberAccount":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AWSAccountId to be of type string, got %T instead", value)
}
sv.MemberAccount = ptr.String(jtv)
}
case "PolicyId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PolicyId to be of type string, got %T instead", value)
}
sv.PolicyId = ptr.String(jtv)
}
case "ResourceDescription":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value)
}
sv.ResourceDescription = ptr.String(jtv)
}
case "ResourceId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value)
}
sv.ResourceId = ptr.String(jtv)
}
case "ResourceTags":
if err := awsAwsjson11_deserializeDocumentTagList(&sv.ResourceTags, value); err != nil {
return err
}
case "ResourceType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value)
}
sv.ResourceType = ptr.String(jtv)
}
case "ResourceViolations":
if err := awsAwsjson11_deserializeDocumentResourceViolations(&sv.ResourceViolations, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentAssociateThirdPartyFirewallOutput(v **AssociateThirdPartyFirewallOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *AssociateThirdPartyFirewallOutput
if *v == nil {
sv = &AssociateThirdPartyFirewallOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ThirdPartyFirewallStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ThirdPartyFirewallAssociationStatus to be of type string, got %T instead", value)
}
sv.ThirdPartyFirewallStatus = types.ThirdPartyFirewallAssociationStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentBatchAssociateResourceOutput(v **BatchAssociateResourceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *BatchAssociateResourceOutput
if *v == nil {
sv = &BatchAssociateResourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "FailedItems":
if err := awsAwsjson11_deserializeDocumentFailedItemList(&sv.FailedItems, value); err != nil {
return err
}
case "ResourceSetIdentifier":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Identifier to be of type string, got %T instead", value)
}
sv.ResourceSetIdentifier = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentBatchDisassociateResourceOutput(v **BatchDisassociateResourceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *BatchDisassociateResourceOutput
if *v == nil {
sv = &BatchDisassociateResourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "FailedItems":
if err := awsAwsjson11_deserializeDocumentFailedItemList(&sv.FailedItems, value); err != nil {
return err
}
case "ResourceSetIdentifier":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected Identifier to be of type string, got %T instead", value)
}
sv.ResourceSetIdentifier = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentDisassociateThirdPartyFirewallOutput(v **DisassociateThirdPartyFirewallOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *DisassociateThirdPartyFirewallOutput
if *v == nil {
sv = &DisassociateThirdPartyFirewallOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ThirdPartyFirewallStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ThirdPartyFirewallAssociationStatus to be of type string, got %T instead", value)
}
sv.ThirdPartyFirewallStatus = types.ThirdPartyFirewallAssociationStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentGetAdminAccountOutput(v **GetAdminAccountOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetAdminAccountOutput
if *v == nil {
sv = &GetAdminAccountOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AdminAccount":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AWSAccountId to be of type string, got %T instead", value)
}
sv.AdminAccount = ptr.String(jtv)
}
case "RoleStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AccountRoleStatus to be of type string, got %T instead", value)
}
sv.RoleStatus = types.AccountRoleStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentGetAdminScopeOutput(v **GetAdminScopeOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetAdminScopeOutput
if *v == nil {
sv = &GetAdminScopeOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AdminScope":
if err := awsAwsjson11_deserializeDocumentAdminScope(&sv.AdminScope, value); err != nil {
return err
}
case "Status":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected OrganizationStatus to be of type string, got %T instead", value)
}
sv.Status = types.OrganizationStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentGetAppsListOutput(v **GetAppsListOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetAppsListOutput
if *v == nil {
sv = &GetAppsListOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AppsList":
if err := awsAwsjson11_deserializeDocumentAppsListData(&sv.AppsList, value); err != nil {
return err
}
case "AppsListArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
}
sv.AppsListArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentGetComplianceDetailOutput(v **GetComplianceDetailOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetComplianceDetailOutput
if *v == nil {
sv = &GetComplianceDetailOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "PolicyComplianceDetail":
if err := awsAwsjson11_deserializeDocumentPolicyComplianceDetail(&sv.PolicyComplianceDetail, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentGetNotificationChannelOutput(v **GetNotificationChannelOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetNotificationChannelOutput
if *v == nil {
sv = &GetNotificationChannelOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "SnsRoleName":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
}
sv.SnsRoleName = ptr.String(jtv)
}
case "SnsTopicArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
}
sv.SnsTopicArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentGetPolicyOutput(v **GetPolicyOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetPolicyOutput
if *v == nil {
sv = &GetPolicyOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Policy":
if err := awsAwsjson11_deserializeDocumentPolicy(&sv.Policy, value); err != nil {
return err
}
case "PolicyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
}
sv.PolicyArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentGetProtectionStatusOutput(v **GetProtectionStatusOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetProtectionStatusOutput
if *v == nil {
sv = &GetProtectionStatusOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AdminAccountId":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected AWSAccountId to be of type string, got %T instead", value)
}
sv.AdminAccountId = ptr.String(jtv)
}
case "Data":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ProtectionData to be of type string, got %T instead", value)
}
sv.Data = ptr.String(jtv)
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "ServiceType":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected SecurityServiceType to be of type string, got %T instead", value)
}
sv.ServiceType = types.SecurityServiceType(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentGetProtocolsListOutput(v **GetProtocolsListOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetProtocolsListOutput
if *v == nil {
sv = &GetProtocolsListOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ProtocolsList":
if err := awsAwsjson11_deserializeDocumentProtocolsListData(&sv.ProtocolsList, value); err != nil {
return err
}
case "ProtocolsListArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
}
sv.ProtocolsListArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentGetResourceSetOutput(v **GetResourceSetOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetResourceSetOutput
if *v == nil {
sv = &GetResourceSetOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ResourceSet":
if err := awsAwsjson11_deserializeDocumentResourceSet(&sv.ResourceSet, value); err != nil {
return err
}
case "ResourceSetArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
}
sv.ResourceSetArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentGetThirdPartyFirewallAssociationStatusOutput(v **GetThirdPartyFirewallAssociationStatusOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetThirdPartyFirewallAssociationStatusOutput
if *v == nil {
sv = &GetThirdPartyFirewallAssociationStatusOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "MarketplaceOnboardingStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected MarketplaceSubscriptionOnboardingStatus to be of type string, got %T instead", value)
}
sv.MarketplaceOnboardingStatus = types.MarketplaceSubscriptionOnboardingStatus(jtv)
}
case "ThirdPartyFirewallStatus":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ThirdPartyFirewallAssociationStatus to be of type string, got %T instead", value)
}
sv.ThirdPartyFirewallStatus = types.ThirdPartyFirewallAssociationStatus(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentGetViolationDetailsOutput(v **GetViolationDetailsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *GetViolationDetailsOutput
if *v == nil {
sv = &GetViolationDetailsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ViolationDetail":
if err := awsAwsjson11_deserializeDocumentViolationDetail(&sv.ViolationDetail, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentListAdminAccountsForOrganizationOutput(v **ListAdminAccountsForOrganizationOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListAdminAccountsForOrganizationOutput
if *v == nil {
sv = &ListAdminAccountsForOrganizationOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AdminAccounts":
if err := awsAwsjson11_deserializeDocumentAdminAccountSummaryList(&sv.AdminAccounts, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentListAdminsManagingAccountOutput(v **ListAdminsManagingAccountOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListAdminsManagingAccountOutput
if *v == nil {
sv = &ListAdminsManagingAccountOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AdminAccounts":
if err := awsAwsjson11_deserializeDocumentAccountIdList(&sv.AdminAccounts, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentListAppsListsOutput(v **ListAppsListsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListAppsListsOutput
if *v == nil {
sv = &ListAppsListsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AppsLists":
if err := awsAwsjson11_deserializeDocumentAppsListsData(&sv.AppsLists, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentListComplianceStatusOutput(v **ListComplianceStatusOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListComplianceStatusOutput
if *v == nil {
sv = &ListComplianceStatusOutput{}
} 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 PaginationToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "PolicyComplianceStatusList":
if err := awsAwsjson11_deserializeDocumentPolicyComplianceStatusList(&sv.PolicyComplianceStatusList, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentListDiscoveredResourcesOutput(v **ListDiscoveredResourcesOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListDiscoveredResourcesOutput
if *v == nil {
sv = &ListDiscoveredResourcesOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Items":
if err := awsAwsjson11_deserializeDocumentDiscoveredResourceList(&sv.Items, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentListMemberAccountsOutput(v **ListMemberAccountsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListMemberAccountsOutput
if *v == nil {
sv = &ListMemberAccountsOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "MemberAccounts":
if err := awsAwsjson11_deserializeDocumentMemberAccounts(&sv.MemberAccounts, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentListPoliciesOutput(v **ListPoliciesOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListPoliciesOutput
if *v == nil {
sv = &ListPoliciesOutput{}
} 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 PaginationToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "PolicyList":
if err := awsAwsjson11_deserializeDocumentPolicySummaryList(&sv.PolicyList, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentListProtocolsListsOutput(v **ListProtocolsListsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListProtocolsListsOutput
if *v == nil {
sv = &ListProtocolsListsOutput{}
} 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 PaginationToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "ProtocolsLists":
if err := awsAwsjson11_deserializeDocumentProtocolsListsData(&sv.ProtocolsLists, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentListResourceSetResourcesOutput(v **ListResourceSetResourcesOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListResourceSetResourcesOutput
if *v == nil {
sv = &ListResourceSetResourcesOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Items":
if err := awsAwsjson11_deserializeDocumentResourceList(&sv.Items, value); err != nil {
return err
}
case "NextToken":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentListResourceSetsOutput(v **ListResourceSetsOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListResourceSetsOutput
if *v == nil {
sv = &ListResourceSetsOutput{}
} 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 PaginationToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "ResourceSets":
if err := awsAwsjson11_deserializeDocumentResourceSetSummaryList(&sv.ResourceSets, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_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 "TagList":
if err := awsAwsjson11_deserializeDocumentTagList(&sv.TagList, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentListThirdPartyFirewallFirewallPoliciesOutput(v **ListThirdPartyFirewallFirewallPoliciesOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *ListThirdPartyFirewallFirewallPoliciesOutput
if *v == nil {
sv = &ListThirdPartyFirewallFirewallPoliciesOutput{}
} 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 PaginationToken to be of type string, got %T instead", value)
}
sv.NextToken = ptr.String(jtv)
}
case "ThirdPartyFirewallFirewallPolicies":
if err := awsAwsjson11_deserializeDocumentThirdPartyFirewallFirewallPolicies(&sv.ThirdPartyFirewallFirewallPolicies, value); err != nil {
return err
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentPutAppsListOutput(v **PutAppsListOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *PutAppsListOutput
if *v == nil {
sv = &PutAppsListOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "AppsList":
if err := awsAwsjson11_deserializeDocumentAppsListData(&sv.AppsList, value); err != nil {
return err
}
case "AppsListArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
}
sv.AppsListArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentPutPolicyOutput(v **PutPolicyOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *PutPolicyOutput
if *v == nil {
sv = &PutPolicyOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "Policy":
if err := awsAwsjson11_deserializeDocumentPolicy(&sv.Policy, value); err != nil {
return err
}
case "PolicyArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
}
sv.PolicyArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentPutProtocolsListOutput(v **PutProtocolsListOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *PutProtocolsListOutput
if *v == nil {
sv = &PutProtocolsListOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ProtocolsList":
if err := awsAwsjson11_deserializeDocumentProtocolsListData(&sv.ProtocolsList, value); err != nil {
return err
}
case "ProtocolsListArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
}
sv.ProtocolsListArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentPutResourceSetOutput(v **PutResourceSetOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *PutResourceSetOutput
if *v == nil {
sv = &PutResourceSetOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
case "ResourceSet":
if err := awsAwsjson11_deserializeDocumentResourceSet(&sv.ResourceSet, value); err != nil {
return err
}
case "ResourceSetArn":
if value != nil {
jtv, ok := value.(string)
if !ok {
return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value)
}
sv.ResourceSetArn = ptr.String(jtv)
}
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *TagResourceOutput
if *v == nil {
sv = &TagResourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
if value == nil {
return nil
}
shape, ok := value.(map[string]interface{})
if !ok {
return fmt.Errorf("unexpected JSON type %v", value)
}
var sv *UntagResourceOutput
if *v == nil {
sv = &UntagResourceOutput{}
} else {
sv = *v
}
for key, value := range shape {
switch key {
default:
_, _ = key, value
}
}
*v = sv
return nil
}
| 13,422 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
// Package fms provides the API client, operations, and parameter types for
// Firewall Management Service.
//
// This is the Firewall Manager API Reference. This guide is for developers who
// need detailed information about the Firewall Manager API actions, data types,
// and errors. For detailed information about Firewall Manager features, see the
// Firewall Manager Developer Guide (https://docs.aws.amazon.com/waf/latest/developerguide/fms-chapter.html)
// . Some API actions require explicit resource permissions. For information, see
// the developer guide topic Service roles for Firewall Manager (https://docs.aws.amazon.com/waf/latest/developerguide/fms-security_iam_service-with-iam.html#fms-security_iam_service-with-iam-roles-service)
// .
package fms
| 14 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
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/fms/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 = "fms"
}
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 fms
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.24.3"
| 7 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
import (
"bytes"
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/fms/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/encoding/httpbinding"
smithyjson "github.com/aws/smithy-go/encoding/json"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
"path"
)
type awsAwsjson11_serializeOpAssociateAdminAccount struct {
}
func (*awsAwsjson11_serializeOpAssociateAdminAccount) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpAssociateAdminAccount) 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.(*AssociateAdminAccountInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.AssociateAdminAccount")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentAssociateAdminAccountInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpAssociateThirdPartyFirewall struct {
}
func (*awsAwsjson11_serializeOpAssociateThirdPartyFirewall) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpAssociateThirdPartyFirewall) 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.(*AssociateThirdPartyFirewallInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.AssociateThirdPartyFirewall")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentAssociateThirdPartyFirewallInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpBatchAssociateResource struct {
}
func (*awsAwsjson11_serializeOpBatchAssociateResource) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpBatchAssociateResource) 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.(*BatchAssociateResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.BatchAssociateResource")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentBatchAssociateResourceInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpBatchDisassociateResource struct {
}
func (*awsAwsjson11_serializeOpBatchDisassociateResource) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpBatchDisassociateResource) 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.(*BatchDisassociateResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.BatchDisassociateResource")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentBatchDisassociateResourceInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteAppsList struct {
}
func (*awsAwsjson11_serializeOpDeleteAppsList) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteAppsList) 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.(*DeleteAppsListInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.DeleteAppsList")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteAppsListInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteNotificationChannel struct {
}
func (*awsAwsjson11_serializeOpDeleteNotificationChannel) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteNotificationChannel) 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.(*DeleteNotificationChannelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.DeleteNotificationChannel")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteNotificationChannelInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeletePolicy struct {
}
func (*awsAwsjson11_serializeOpDeletePolicy) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeletePolicy) 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.(*DeletePolicyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.DeletePolicy")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeletePolicyInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteProtocolsList struct {
}
func (*awsAwsjson11_serializeOpDeleteProtocolsList) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteProtocolsList) 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.(*DeleteProtocolsListInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.DeleteProtocolsList")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteProtocolsListInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDeleteResourceSet struct {
}
func (*awsAwsjson11_serializeOpDeleteResourceSet) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDeleteResourceSet) 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.(*DeleteResourceSetInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.DeleteResourceSet")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDeleteResourceSetInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDisassociateAdminAccount struct {
}
func (*awsAwsjson11_serializeOpDisassociateAdminAccount) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDisassociateAdminAccount) 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.(*DisassociateAdminAccountInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.DisassociateAdminAccount")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDisassociateAdminAccountInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpDisassociateThirdPartyFirewall struct {
}
func (*awsAwsjson11_serializeOpDisassociateThirdPartyFirewall) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpDisassociateThirdPartyFirewall) 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.(*DisassociateThirdPartyFirewallInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.DisassociateThirdPartyFirewall")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentDisassociateThirdPartyFirewallInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpGetAdminAccount struct {
}
func (*awsAwsjson11_serializeOpGetAdminAccount) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpGetAdminAccount) 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.(*GetAdminAccountInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.GetAdminAccount")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentGetAdminAccountInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpGetAdminScope struct {
}
func (*awsAwsjson11_serializeOpGetAdminScope) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpGetAdminScope) 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.(*GetAdminScopeInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.GetAdminScope")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentGetAdminScopeInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpGetAppsList struct {
}
func (*awsAwsjson11_serializeOpGetAppsList) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpGetAppsList) 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.(*GetAppsListInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.GetAppsList")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentGetAppsListInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpGetComplianceDetail struct {
}
func (*awsAwsjson11_serializeOpGetComplianceDetail) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpGetComplianceDetail) 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.(*GetComplianceDetailInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.GetComplianceDetail")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentGetComplianceDetailInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpGetNotificationChannel struct {
}
func (*awsAwsjson11_serializeOpGetNotificationChannel) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpGetNotificationChannel) 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.(*GetNotificationChannelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.GetNotificationChannel")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentGetNotificationChannelInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpGetPolicy struct {
}
func (*awsAwsjson11_serializeOpGetPolicy) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpGetPolicy) 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.(*GetPolicyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.GetPolicy")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentGetPolicyInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpGetProtectionStatus struct {
}
func (*awsAwsjson11_serializeOpGetProtectionStatus) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpGetProtectionStatus) 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.(*GetProtectionStatusInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.GetProtectionStatus")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentGetProtectionStatusInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpGetProtocolsList struct {
}
func (*awsAwsjson11_serializeOpGetProtocolsList) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpGetProtocolsList) 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.(*GetProtocolsListInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.GetProtocolsList")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentGetProtocolsListInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpGetResourceSet struct {
}
func (*awsAwsjson11_serializeOpGetResourceSet) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpGetResourceSet) 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.(*GetResourceSetInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.GetResourceSet")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentGetResourceSetInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpGetThirdPartyFirewallAssociationStatus struct {
}
func (*awsAwsjson11_serializeOpGetThirdPartyFirewallAssociationStatus) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpGetThirdPartyFirewallAssociationStatus) 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.(*GetThirdPartyFirewallAssociationStatusInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.GetThirdPartyFirewallAssociationStatus")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentGetThirdPartyFirewallAssociationStatusInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpGetViolationDetails struct {
}
func (*awsAwsjson11_serializeOpGetViolationDetails) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpGetViolationDetails) 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.(*GetViolationDetailsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.GetViolationDetails")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentGetViolationDetailsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListAdminAccountsForOrganization struct {
}
func (*awsAwsjson11_serializeOpListAdminAccountsForOrganization) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListAdminAccountsForOrganization) 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.(*ListAdminAccountsForOrganizationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.ListAdminAccountsForOrganization")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListAdminAccountsForOrganizationInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListAdminsManagingAccount struct {
}
func (*awsAwsjson11_serializeOpListAdminsManagingAccount) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListAdminsManagingAccount) 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.(*ListAdminsManagingAccountInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.ListAdminsManagingAccount")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListAdminsManagingAccountInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListAppsLists struct {
}
func (*awsAwsjson11_serializeOpListAppsLists) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListAppsLists) 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.(*ListAppsListsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.ListAppsLists")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListAppsListsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListComplianceStatus struct {
}
func (*awsAwsjson11_serializeOpListComplianceStatus) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListComplianceStatus) 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.(*ListComplianceStatusInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.ListComplianceStatus")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListComplianceStatusInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListDiscoveredResources struct {
}
func (*awsAwsjson11_serializeOpListDiscoveredResources) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListDiscoveredResources) 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.(*ListDiscoveredResourcesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.ListDiscoveredResources")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListDiscoveredResourcesInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListMemberAccounts struct {
}
func (*awsAwsjson11_serializeOpListMemberAccounts) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListMemberAccounts) 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.(*ListMemberAccountsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.ListMemberAccounts")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListMemberAccountsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListPolicies struct {
}
func (*awsAwsjson11_serializeOpListPolicies) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListPolicies) 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.(*ListPoliciesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.ListPolicies")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListPoliciesInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListProtocolsLists struct {
}
func (*awsAwsjson11_serializeOpListProtocolsLists) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListProtocolsLists) 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.(*ListProtocolsListsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.ListProtocolsLists")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListProtocolsListsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListResourceSetResources struct {
}
func (*awsAwsjson11_serializeOpListResourceSetResources) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListResourceSetResources) 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.(*ListResourceSetResourcesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.ListResourceSetResources")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListResourceSetResourcesInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListResourceSets struct {
}
func (*awsAwsjson11_serializeOpListResourceSets) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListResourceSets) 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.(*ListResourceSetsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.ListResourceSets")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListResourceSetsInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListTagsForResource struct {
}
func (*awsAwsjson11_serializeOpListTagsForResource) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_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)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.ListTagsForResource")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListTagsForResourceInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpListThirdPartyFirewallFirewallPolicies struct {
}
func (*awsAwsjson11_serializeOpListThirdPartyFirewallFirewallPolicies) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpListThirdPartyFirewallFirewallPolicies) 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.(*ListThirdPartyFirewallFirewallPoliciesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.ListThirdPartyFirewallFirewallPolicies")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentListThirdPartyFirewallFirewallPoliciesInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpPutAdminAccount struct {
}
func (*awsAwsjson11_serializeOpPutAdminAccount) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpPutAdminAccount) 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.(*PutAdminAccountInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.PutAdminAccount")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentPutAdminAccountInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpPutAppsList struct {
}
func (*awsAwsjson11_serializeOpPutAppsList) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpPutAppsList) 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.(*PutAppsListInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.PutAppsList")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentPutAppsListInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpPutNotificationChannel struct {
}
func (*awsAwsjson11_serializeOpPutNotificationChannel) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpPutNotificationChannel) 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.(*PutNotificationChannelInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.PutNotificationChannel")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentPutNotificationChannelInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpPutPolicy struct {
}
func (*awsAwsjson11_serializeOpPutPolicy) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpPutPolicy) 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.(*PutPolicyInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.PutPolicy")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentPutPolicyInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpPutProtocolsList struct {
}
func (*awsAwsjson11_serializeOpPutProtocolsList) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpPutProtocolsList) 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.(*PutProtocolsListInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.PutProtocolsList")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentPutProtocolsListInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpPutResourceSet struct {
}
func (*awsAwsjson11_serializeOpPutResourceSet) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpPutResourceSet) 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.(*PutResourceSetInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.PutResourceSet")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentPutResourceSetInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpTagResource struct {
}
func (*awsAwsjson11_serializeOpTagResource) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*TagResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.TagResource")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
type awsAwsjson11_serializeOpUntagResource struct {
}
func (*awsAwsjson11_serializeOpUntagResource) ID() string {
return "OperationSerializer"
}
func (m *awsAwsjson11_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
request, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
input, ok := in.Parameters.(*UntagResourceInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
}
operationPath := "/"
if len(request.Request.URL.Path) == 0 {
request.Request.URL.Path = operationPath
} else {
request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
request.Request.URL.Path += "/"
}
}
request.Request.Method = "POST"
httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
if err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
httpBindingEncoder.SetHeader("X-Amz-Target").String("AWSFMS_20180101.UntagResource")
jsonEncoder := smithyjson.NewEncoder()
if err := awsAwsjson11_serializeOpDocumentUntagResourceInput(input, jsonEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
in.Request = request
return next.HandleSerialize(ctx, in)
}
func awsAwsjson11_serializeDocumentAccountIdList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentAccountScope(v *types.AccountScope, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Accounts != nil {
ok := object.Key("Accounts")
if err := awsAwsjson11_serializeDocumentAccountIdList(v.Accounts, ok); err != nil {
return err
}
}
if v.AllAccountsEnabled {
ok := object.Key("AllAccountsEnabled")
ok.Boolean(v.AllAccountsEnabled)
}
if v.ExcludeSpecifiedAccounts {
ok := object.Key("ExcludeSpecifiedAccounts")
ok.Boolean(v.ExcludeSpecifiedAccounts)
}
return nil
}
func awsAwsjson11_serializeDocumentAdminScope(v *types.AdminScope, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AccountScope != nil {
ok := object.Key("AccountScope")
if err := awsAwsjson11_serializeDocumentAccountScope(v.AccountScope, ok); err != nil {
return err
}
}
if v.OrganizationalUnitScope != nil {
ok := object.Key("OrganizationalUnitScope")
if err := awsAwsjson11_serializeDocumentOrganizationalUnitScope(v.OrganizationalUnitScope, ok); err != nil {
return err
}
}
if v.PolicyTypeScope != nil {
ok := object.Key("PolicyTypeScope")
if err := awsAwsjson11_serializeDocumentPolicyTypeScope(v.PolicyTypeScope, ok); err != nil {
return err
}
}
if v.RegionScope != nil {
ok := object.Key("RegionScope")
if err := awsAwsjson11_serializeDocumentRegionScope(v.RegionScope, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentApp(v *types.App, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AppName != nil {
ok := object.Key("AppName")
ok.String(*v.AppName)
}
if v.Port != nil {
ok := object.Key("Port")
ok.Long(*v.Port)
}
if v.Protocol != nil {
ok := object.Key("Protocol")
ok.String(*v.Protocol)
}
return nil
}
func awsAwsjson11_serializeDocumentAppsList(v []types.App, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsAwsjson11_serializeDocumentApp(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentAppsListData(v *types.AppsListData, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AppsList != nil {
ok := object.Key("AppsList")
if err := awsAwsjson11_serializeDocumentAppsList(v.AppsList, ok); err != nil {
return err
}
}
if v.CreateTime != nil {
ok := object.Key("CreateTime")
ok.Double(smithytime.FormatEpochSeconds(*v.CreateTime))
}
if v.LastUpdateTime != nil {
ok := object.Key("LastUpdateTime")
ok.Double(smithytime.FormatEpochSeconds(*v.LastUpdateTime))
}
if v.ListId != nil {
ok := object.Key("ListId")
ok.String(*v.ListId)
}
if v.ListName != nil {
ok := object.Key("ListName")
ok.String(*v.ListName)
}
if v.ListUpdateToken != nil {
ok := object.Key("ListUpdateToken")
ok.String(*v.ListUpdateToken)
}
if v.PreviousAppsList != nil {
ok := object.Key("PreviousAppsList")
if err := awsAwsjson11_serializeDocumentPreviousAppsList(v.PreviousAppsList, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentAWSAccountIdList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentAWSRegionList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentCustomerPolicyScopeIdList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentCustomerPolicyScopeMap(v map[string][]string, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
if vv := v[key]; vv == nil {
continue
}
if err := awsAwsjson11_serializeDocumentCustomerPolicyScopeIdList(v[key], om); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentIdentifierList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentNetworkFirewallPolicy(v *types.NetworkFirewallPolicy, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.FirewallDeploymentModel) > 0 {
ok := object.Key("FirewallDeploymentModel")
ok.String(string(v.FirewallDeploymentModel))
}
return nil
}
func awsAwsjson11_serializeDocumentOrganizationalUnitIdList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentOrganizationalUnitScope(v *types.OrganizationalUnitScope, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AllOrganizationalUnitsEnabled {
ok := object.Key("AllOrganizationalUnitsEnabled")
ok.Boolean(v.AllOrganizationalUnitsEnabled)
}
if v.ExcludeSpecifiedOrganizationalUnits {
ok := object.Key("ExcludeSpecifiedOrganizationalUnits")
ok.Boolean(v.ExcludeSpecifiedOrganizationalUnits)
}
if v.OrganizationalUnits != nil {
ok := object.Key("OrganizationalUnits")
if err := awsAwsjson11_serializeDocumentOrganizationalUnitIdList(v.OrganizationalUnits, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentPolicy(v *types.Policy, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DeleteUnusedFMManagedResources {
ok := object.Key("DeleteUnusedFMManagedResources")
ok.Boolean(v.DeleteUnusedFMManagedResources)
}
if v.ExcludeMap != nil {
ok := object.Key("ExcludeMap")
if err := awsAwsjson11_serializeDocumentCustomerPolicyScopeMap(v.ExcludeMap, ok); err != nil {
return err
}
}
{
ok := object.Key("ExcludeResourceTags")
ok.Boolean(v.ExcludeResourceTags)
}
if v.IncludeMap != nil {
ok := object.Key("IncludeMap")
if err := awsAwsjson11_serializeDocumentCustomerPolicyScopeMap(v.IncludeMap, ok); err != nil {
return err
}
}
if v.PolicyDescription != nil {
ok := object.Key("PolicyDescription")
ok.String(*v.PolicyDescription)
}
if v.PolicyId != nil {
ok := object.Key("PolicyId")
ok.String(*v.PolicyId)
}
if v.PolicyName != nil {
ok := object.Key("PolicyName")
ok.String(*v.PolicyName)
}
if len(v.PolicyStatus) > 0 {
ok := object.Key("PolicyStatus")
ok.String(string(v.PolicyStatus))
}
if v.PolicyUpdateToken != nil {
ok := object.Key("PolicyUpdateToken")
ok.String(*v.PolicyUpdateToken)
}
{
ok := object.Key("RemediationEnabled")
ok.Boolean(v.RemediationEnabled)
}
if v.ResourceSetIds != nil {
ok := object.Key("ResourceSetIds")
if err := awsAwsjson11_serializeDocumentResourceSetIds(v.ResourceSetIds, ok); err != nil {
return err
}
}
if v.ResourceTags != nil {
ok := object.Key("ResourceTags")
if err := awsAwsjson11_serializeDocumentResourceTags(v.ResourceTags, ok); err != nil {
return err
}
}
if v.ResourceType != nil {
ok := object.Key("ResourceType")
ok.String(*v.ResourceType)
}
if v.ResourceTypeList != nil {
ok := object.Key("ResourceTypeList")
if err := awsAwsjson11_serializeDocumentResourceTypeList(v.ResourceTypeList, ok); err != nil {
return err
}
}
if v.SecurityServicePolicyData != nil {
ok := object.Key("SecurityServicePolicyData")
if err := awsAwsjson11_serializeDocumentSecurityServicePolicyData(v.SecurityServicePolicyData, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentPolicyOption(v *types.PolicyOption, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.NetworkFirewallPolicy != nil {
ok := object.Key("NetworkFirewallPolicy")
if err := awsAwsjson11_serializeDocumentNetworkFirewallPolicy(v.NetworkFirewallPolicy, ok); err != nil {
return err
}
}
if v.ThirdPartyFirewallPolicy != nil {
ok := object.Key("ThirdPartyFirewallPolicy")
if err := awsAwsjson11_serializeDocumentThirdPartyFirewallPolicy(v.ThirdPartyFirewallPolicy, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentPolicyTypeScope(v *types.PolicyTypeScope, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AllPolicyTypesEnabled {
ok := object.Key("AllPolicyTypesEnabled")
ok.Boolean(v.AllPolicyTypesEnabled)
}
if v.PolicyTypes != nil {
ok := object.Key("PolicyTypes")
if err := awsAwsjson11_serializeDocumentSecurityServiceTypeList(v.PolicyTypes, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentPreviousAppsList(v map[string][]types.App, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
if vv := v[key]; vv == nil {
continue
}
if err := awsAwsjson11_serializeDocumentAppsList(v[key], om); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentPreviousProtocolsList(v map[string][]string, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
for key := range v {
om := object.Key(key)
if vv := v[key]; vv == nil {
continue
}
if err := awsAwsjson11_serializeDocumentProtocolsList(v[key], om); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentProtocolsList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentProtocolsListData(v *types.ProtocolsListData, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.CreateTime != nil {
ok := object.Key("CreateTime")
ok.Double(smithytime.FormatEpochSeconds(*v.CreateTime))
}
if v.LastUpdateTime != nil {
ok := object.Key("LastUpdateTime")
ok.Double(smithytime.FormatEpochSeconds(*v.LastUpdateTime))
}
if v.ListId != nil {
ok := object.Key("ListId")
ok.String(*v.ListId)
}
if v.ListName != nil {
ok := object.Key("ListName")
ok.String(*v.ListName)
}
if v.ListUpdateToken != nil {
ok := object.Key("ListUpdateToken")
ok.String(*v.ListUpdateToken)
}
if v.PreviousProtocolsList != nil {
ok := object.Key("PreviousProtocolsList")
if err := awsAwsjson11_serializeDocumentPreviousProtocolsList(v.PreviousProtocolsList, ok); err != nil {
return err
}
}
if v.ProtocolsList != nil {
ok := object.Key("ProtocolsList")
if err := awsAwsjson11_serializeDocumentProtocolsList(v.ProtocolsList, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentRegionScope(v *types.RegionScope, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AllRegionsEnabled {
ok := object.Key("AllRegionsEnabled")
ok.Boolean(v.AllRegionsEnabled)
}
if v.Regions != nil {
ok := object.Key("Regions")
if err := awsAwsjson11_serializeDocumentAWSRegionList(v.Regions, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentResourceSet(v *types.ResourceSet, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Description != nil {
ok := object.Key("Description")
ok.String(*v.Description)
}
if v.Id != nil {
ok := object.Key("Id")
ok.String(*v.Id)
}
if v.LastUpdateTime != nil {
ok := object.Key("LastUpdateTime")
ok.Double(smithytime.FormatEpochSeconds(*v.LastUpdateTime))
}
if v.Name != nil {
ok := object.Key("Name")
ok.String(*v.Name)
}
if len(v.ResourceSetStatus) > 0 {
ok := object.Key("ResourceSetStatus")
ok.String(string(v.ResourceSetStatus))
}
if v.ResourceTypeList != nil {
ok := object.Key("ResourceTypeList")
if err := awsAwsjson11_serializeDocumentResourceTypeList(v.ResourceTypeList, ok); err != nil {
return err
}
}
if v.UpdateToken != nil {
ok := object.Key("UpdateToken")
ok.String(*v.UpdateToken)
}
return nil
}
func awsAwsjson11_serializeDocumentResourceSetIds(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentResourceTag(v *types.ResourceTag, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Key != nil {
ok := object.Key("Key")
ok.String(*v.Key)
}
if v.Value != nil {
ok := object.Key("Value")
ok.String(*v.Value)
}
return nil
}
func awsAwsjson11_serializeDocumentResourceTags(v []types.ResourceTag, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsAwsjson11_serializeDocumentResourceTag(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentResourceTypeList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentSecurityServicePolicyData(v *types.SecurityServicePolicyData, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ManagedServiceData != nil {
ok := object.Key("ManagedServiceData")
ok.String(*v.ManagedServiceData)
}
if v.PolicyOption != nil {
ok := object.Key("PolicyOption")
if err := awsAwsjson11_serializeDocumentPolicyOption(v.PolicyOption, ok); err != nil {
return err
}
}
if len(v.Type) > 0 {
ok := object.Key("Type")
ok.String(string(v.Type))
}
return nil
}
func awsAwsjson11_serializeDocumentSecurityServiceTypeList(v []types.SecurityServiceType, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(string(v[i]))
}
return nil
}
func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Key != nil {
ok := object.Key("Key")
ok.String(*v.Key)
}
if v.Value != nil {
ok := object.Key("Value")
ok.String(*v.Value)
}
return nil
}
func awsAwsjson11_serializeDocumentTagKeyList(v []string, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
av.String(v[i])
}
return nil
}
func awsAwsjson11_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error {
array := value.Array()
defer array.Close()
for i := range v {
av := array.Value()
if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeDocumentThirdPartyFirewallPolicy(v *types.ThirdPartyFirewallPolicy, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.FirewallDeploymentModel) > 0 {
ok := object.Key("FirewallDeploymentModel")
ok.String(string(v.FirewallDeploymentModel))
}
return nil
}
func awsAwsjson11_serializeOpDocumentAssociateAdminAccountInput(v *AssociateAdminAccountInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AdminAccount != nil {
ok := object.Key("AdminAccount")
ok.String(*v.AdminAccount)
}
return nil
}
func awsAwsjson11_serializeOpDocumentAssociateThirdPartyFirewallInput(v *AssociateThirdPartyFirewallInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.ThirdPartyFirewall) > 0 {
ok := object.Key("ThirdPartyFirewall")
ok.String(string(v.ThirdPartyFirewall))
}
return nil
}
func awsAwsjson11_serializeOpDocumentBatchAssociateResourceInput(v *BatchAssociateResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Items != nil {
ok := object.Key("Items")
if err := awsAwsjson11_serializeDocumentIdentifierList(v.Items, ok); err != nil {
return err
}
}
if v.ResourceSetIdentifier != nil {
ok := object.Key("ResourceSetIdentifier")
ok.String(*v.ResourceSetIdentifier)
}
return nil
}
func awsAwsjson11_serializeOpDocumentBatchDisassociateResourceInput(v *BatchDisassociateResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Items != nil {
ok := object.Key("Items")
if err := awsAwsjson11_serializeDocumentIdentifierList(v.Items, ok); err != nil {
return err
}
}
if v.ResourceSetIdentifier != nil {
ok := object.Key("ResourceSetIdentifier")
ok.String(*v.ResourceSetIdentifier)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteAppsListInput(v *DeleteAppsListInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ListId != nil {
ok := object.Key("ListId")
ok.String(*v.ListId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteNotificationChannelInput(v *DeleteNotificationChannelInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsAwsjson11_serializeOpDocumentDeletePolicyInput(v *DeletePolicyInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DeleteAllPolicyResources {
ok := object.Key("DeleteAllPolicyResources")
ok.Boolean(v.DeleteAllPolicyResources)
}
if v.PolicyId != nil {
ok := object.Key("PolicyId")
ok.String(*v.PolicyId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteProtocolsListInput(v *DeleteProtocolsListInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ListId != nil {
ok := object.Key("ListId")
ok.String(*v.ListId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDeleteResourceSetInput(v *DeleteResourceSetInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Identifier != nil {
ok := object.Key("Identifier")
ok.String(*v.Identifier)
}
return nil
}
func awsAwsjson11_serializeOpDocumentDisassociateAdminAccountInput(v *DisassociateAdminAccountInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsAwsjson11_serializeOpDocumentDisassociateThirdPartyFirewallInput(v *DisassociateThirdPartyFirewallInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.ThirdPartyFirewall) > 0 {
ok := object.Key("ThirdPartyFirewall")
ok.String(string(v.ThirdPartyFirewall))
}
return nil
}
func awsAwsjson11_serializeOpDocumentGetAdminAccountInput(v *GetAdminAccountInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsAwsjson11_serializeOpDocumentGetAdminScopeInput(v *GetAdminScopeInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AdminAccount != nil {
ok := object.Key("AdminAccount")
ok.String(*v.AdminAccount)
}
return nil
}
func awsAwsjson11_serializeOpDocumentGetAppsListInput(v *GetAppsListInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DefaultList {
ok := object.Key("DefaultList")
ok.Boolean(v.DefaultList)
}
if v.ListId != nil {
ok := object.Key("ListId")
ok.String(*v.ListId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentGetComplianceDetailInput(v *GetComplianceDetailInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MemberAccount != nil {
ok := object.Key("MemberAccount")
ok.String(*v.MemberAccount)
}
if v.PolicyId != nil {
ok := object.Key("PolicyId")
ok.String(*v.PolicyId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentGetNotificationChannelInput(v *GetNotificationChannelInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
return nil
}
func awsAwsjson11_serializeOpDocumentGetPolicyInput(v *GetPolicyInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.PolicyId != nil {
ok := object.Key("PolicyId")
ok.String(*v.PolicyId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentGetProtectionStatusInput(v *GetProtectionStatusInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.EndTime != nil {
ok := object.Key("EndTime")
ok.Double(smithytime.FormatEpochSeconds(*v.EndTime))
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.MemberAccountId != nil {
ok := object.Key("MemberAccountId")
ok.String(*v.MemberAccountId)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.PolicyId != nil {
ok := object.Key("PolicyId")
ok.String(*v.PolicyId)
}
if v.StartTime != nil {
ok := object.Key("StartTime")
ok.Double(smithytime.FormatEpochSeconds(*v.StartTime))
}
return nil
}
func awsAwsjson11_serializeOpDocumentGetProtocolsListInput(v *GetProtocolsListInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DefaultList {
ok := object.Key("DefaultList")
ok.Boolean(v.DefaultList)
}
if v.ListId != nil {
ok := object.Key("ListId")
ok.String(*v.ListId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentGetResourceSetInput(v *GetResourceSetInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Identifier != nil {
ok := object.Key("Identifier")
ok.String(*v.Identifier)
}
return nil
}
func awsAwsjson11_serializeOpDocumentGetThirdPartyFirewallAssociationStatusInput(v *GetThirdPartyFirewallAssociationStatusInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if len(v.ThirdPartyFirewall) > 0 {
ok := object.Key("ThirdPartyFirewall")
ok.String(string(v.ThirdPartyFirewall))
}
return nil
}
func awsAwsjson11_serializeOpDocumentGetViolationDetailsInput(v *GetViolationDetailsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MemberAccount != nil {
ok := object.Key("MemberAccount")
ok.String(*v.MemberAccount)
}
if v.PolicyId != nil {
ok := object.Key("PolicyId")
ok.String(*v.PolicyId)
}
if v.ResourceId != nil {
ok := object.Key("ResourceId")
ok.String(*v.ResourceId)
}
if v.ResourceType != nil {
ok := object.Key("ResourceType")
ok.String(*v.ResourceType)
}
return nil
}
func awsAwsjson11_serializeOpDocumentListAdminAccountsForOrganizationInput(v *ListAdminAccountsForOrganizationInput, 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
}
func awsAwsjson11_serializeOpDocumentListAdminsManagingAccountInput(v *ListAdminsManagingAccountInput, 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
}
func awsAwsjson11_serializeOpDocumentListAppsListsInput(v *ListAppsListsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DefaultLists {
ok := object.Key("DefaultLists")
ok.Boolean(v.DefaultLists)
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentListComplianceStatusInput(v *ListComplianceStatusInput, 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.PolicyId != nil {
ok := object.Key("PolicyId")
ok.String(*v.PolicyId)
}
return nil
}
func awsAwsjson11_serializeOpDocumentListDiscoveredResourcesInput(v *ListDiscoveredResourcesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.MemberAccountIds != nil {
ok := object.Key("MemberAccountIds")
if err := awsAwsjson11_serializeDocumentAWSAccountIdList(v.MemberAccountIds, ok); err != nil {
return err
}
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
if v.ResourceType != nil {
ok := object.Key("ResourceType")
ok.String(*v.ResourceType)
}
return nil
}
func awsAwsjson11_serializeOpDocumentListMemberAccountsInput(v *ListMemberAccountsInput, 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
}
func awsAwsjson11_serializeOpDocumentListPoliciesInput(v *ListPoliciesInput, 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
}
func awsAwsjson11_serializeOpDocumentListProtocolsListsInput(v *ListProtocolsListsInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.DefaultLists {
ok := object.Key("DefaultLists")
ok.Boolean(v.DefaultLists)
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentListResourceSetResourcesInput(v *ListResourceSetResourcesInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Identifier != nil {
ok := object.Key("Identifier")
ok.String(*v.Identifier)
}
if v.MaxResults != nil {
ok := object.Key("MaxResults")
ok.Integer(*v.MaxResults)
}
if v.NextToken != nil {
ok := object.Key("NextToken")
ok.String(*v.NextToken)
}
return nil
}
func awsAwsjson11_serializeOpDocumentListResourceSetsInput(v *ListResourceSetsInput, 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
}
func awsAwsjson11_serializeOpDocumentListTagsForResourceInput(v *ListTagsForResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ResourceArn != nil {
ok := object.Key("ResourceArn")
ok.String(*v.ResourceArn)
}
return nil
}
func awsAwsjson11_serializeOpDocumentListThirdPartyFirewallFirewallPoliciesInput(v *ListThirdPartyFirewallFirewallPoliciesInput, 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.ThirdPartyFirewall) > 0 {
ok := object.Key("ThirdPartyFirewall")
ok.String(string(v.ThirdPartyFirewall))
}
return nil
}
func awsAwsjson11_serializeOpDocumentPutAdminAccountInput(v *PutAdminAccountInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AdminAccount != nil {
ok := object.Key("AdminAccount")
ok.String(*v.AdminAccount)
}
if v.AdminScope != nil {
ok := object.Key("AdminScope")
if err := awsAwsjson11_serializeDocumentAdminScope(v.AdminScope, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentPutAppsListInput(v *PutAppsListInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.AppsList != nil {
ok := object.Key("AppsList")
if err := awsAwsjson11_serializeDocumentAppsListData(v.AppsList, ok); err != nil {
return err
}
}
if v.TagList != nil {
ok := object.Key("TagList")
if err := awsAwsjson11_serializeDocumentTagList(v.TagList, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentPutNotificationChannelInput(v *PutNotificationChannelInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.SnsRoleName != nil {
ok := object.Key("SnsRoleName")
ok.String(*v.SnsRoleName)
}
if v.SnsTopicArn != nil {
ok := object.Key("SnsTopicArn")
ok.String(*v.SnsTopicArn)
}
return nil
}
func awsAwsjson11_serializeOpDocumentPutPolicyInput(v *PutPolicyInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.Policy != nil {
ok := object.Key("Policy")
if err := awsAwsjson11_serializeDocumentPolicy(v.Policy, ok); err != nil {
return err
}
}
if v.TagList != nil {
ok := object.Key("TagList")
if err := awsAwsjson11_serializeDocumentTagList(v.TagList, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentPutProtocolsListInput(v *PutProtocolsListInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ProtocolsList != nil {
ok := object.Key("ProtocolsList")
if err := awsAwsjson11_serializeDocumentProtocolsListData(v.ProtocolsList, ok); err != nil {
return err
}
}
if v.TagList != nil {
ok := object.Key("TagList")
if err := awsAwsjson11_serializeDocumentTagList(v.TagList, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentPutResourceSetInput(v *PutResourceSetInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ResourceSet != nil {
ok := object.Key("ResourceSet")
if err := awsAwsjson11_serializeDocumentResourceSet(v.ResourceSet, ok); err != nil {
return err
}
}
if v.TagList != nil {
ok := object.Key("TagList")
if err := awsAwsjson11_serializeDocumentTagList(v.TagList, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ResourceArn != nil {
ok := object.Key("ResourceArn")
ok.String(*v.ResourceArn)
}
if v.TagList != nil {
ok := object.Key("TagList")
if err := awsAwsjson11_serializeDocumentTagList(v.TagList, ok); err != nil {
return err
}
}
return nil
}
func awsAwsjson11_serializeOpDocumentUntagResourceInput(v *UntagResourceInput, value smithyjson.Value) error {
object := value.Object()
defer object.Close()
if v.ResourceArn != nil {
ok := object.Key("ResourceArn")
ok.String(*v.ResourceArn)
}
if v.TagKeys != nil {
ok := object.Key("TagKeys")
if err := awsAwsjson11_serializeDocumentTagKeyList(v.TagKeys, ok); err != nil {
return err
}
}
return nil
}
| 3,723 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package fms
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/fms/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpAssociateAdminAccount struct {
}
func (*validateOpAssociateAdminAccount) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAssociateAdminAccount) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AssociateAdminAccountInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAssociateAdminAccountInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpAssociateThirdPartyFirewall struct {
}
func (*validateOpAssociateThirdPartyFirewall) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAssociateThirdPartyFirewall) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AssociateThirdPartyFirewallInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAssociateThirdPartyFirewallInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpBatchAssociateResource struct {
}
func (*validateOpBatchAssociateResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpBatchAssociateResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*BatchAssociateResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpBatchAssociateResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpBatchDisassociateResource struct {
}
func (*validateOpBatchDisassociateResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpBatchDisassociateResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*BatchDisassociateResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpBatchDisassociateResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteAppsList struct {
}
func (*validateOpDeleteAppsList) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteAppsList) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteAppsListInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteAppsListInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeletePolicy struct {
}
func (*validateOpDeletePolicy) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeletePolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeletePolicyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeletePolicyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteProtocolsList struct {
}
func (*validateOpDeleteProtocolsList) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteProtocolsList) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteProtocolsListInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteProtocolsListInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteResourceSet struct {
}
func (*validateOpDeleteResourceSet) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteResourceSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteResourceSetInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteResourceSetInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDisassociateThirdPartyFirewall struct {
}
func (*validateOpDisassociateThirdPartyFirewall) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDisassociateThirdPartyFirewall) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DisassociateThirdPartyFirewallInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDisassociateThirdPartyFirewallInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetAdminScope struct {
}
func (*validateOpGetAdminScope) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetAdminScope) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetAdminScopeInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetAdminScopeInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetAppsList struct {
}
func (*validateOpGetAppsList) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetAppsList) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetAppsListInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetAppsListInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetComplianceDetail struct {
}
func (*validateOpGetComplianceDetail) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetComplianceDetail) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetComplianceDetailInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetComplianceDetailInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetPolicy struct {
}
func (*validateOpGetPolicy) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetPolicyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetPolicyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetProtectionStatus struct {
}
func (*validateOpGetProtectionStatus) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetProtectionStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetProtectionStatusInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetProtectionStatusInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetProtocolsList struct {
}
func (*validateOpGetProtocolsList) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetProtocolsList) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetProtocolsListInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetProtocolsListInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetResourceSet struct {
}
func (*validateOpGetResourceSet) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetResourceSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetResourceSetInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetResourceSetInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetThirdPartyFirewallAssociationStatus struct {
}
func (*validateOpGetThirdPartyFirewallAssociationStatus) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetThirdPartyFirewallAssociationStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetThirdPartyFirewallAssociationStatusInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetThirdPartyFirewallAssociationStatusInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpGetViolationDetails struct {
}
func (*validateOpGetViolationDetails) ID() string {
return "OperationInputValidation"
}
func (m *validateOpGetViolationDetails) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*GetViolationDetailsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpGetViolationDetailsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListAppsLists struct {
}
func (*validateOpListAppsLists) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListAppsLists) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListAppsListsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListAppsListsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListComplianceStatus struct {
}
func (*validateOpListComplianceStatus) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListComplianceStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListComplianceStatusInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListComplianceStatusInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListDiscoveredResources struct {
}
func (*validateOpListDiscoveredResources) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListDiscoveredResources) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListDiscoveredResourcesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListDiscoveredResourcesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListProtocolsLists struct {
}
func (*validateOpListProtocolsLists) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListProtocolsLists) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListProtocolsListsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListProtocolsListsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListResourceSetResources struct {
}
func (*validateOpListResourceSetResources) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListResourceSetResources) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListResourceSetResourcesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListResourceSetResourcesInput(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 validateOpListThirdPartyFirewallFirewallPolicies struct {
}
func (*validateOpListThirdPartyFirewallFirewallPolicies) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListThirdPartyFirewallFirewallPolicies) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListThirdPartyFirewallFirewallPoliciesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListThirdPartyFirewallFirewallPoliciesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpPutAdminAccount struct {
}
func (*validateOpPutAdminAccount) ID() string {
return "OperationInputValidation"
}
func (m *validateOpPutAdminAccount) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*PutAdminAccountInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpPutAdminAccountInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpPutAppsList struct {
}
func (*validateOpPutAppsList) ID() string {
return "OperationInputValidation"
}
func (m *validateOpPutAppsList) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*PutAppsListInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpPutAppsListInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpPutNotificationChannel struct {
}
func (*validateOpPutNotificationChannel) ID() string {
return "OperationInputValidation"
}
func (m *validateOpPutNotificationChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*PutNotificationChannelInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpPutNotificationChannelInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpPutPolicy struct {
}
func (*validateOpPutPolicy) ID() string {
return "OperationInputValidation"
}
func (m *validateOpPutPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*PutPolicyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpPutPolicyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpPutProtocolsList struct {
}
func (*validateOpPutProtocolsList) ID() string {
return "OperationInputValidation"
}
func (m *validateOpPutProtocolsList) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*PutProtocolsListInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpPutProtocolsListInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpPutResourceSet struct {
}
func (*validateOpPutResourceSet) ID() string {
return "OperationInputValidation"
}
func (m *validateOpPutResourceSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*PutResourceSetInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpPutResourceSetInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpTagResource struct {
}
func (*validateOpTagResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*TagResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpTagResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUntagResource struct {
}
func (*validateOpUntagResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UntagResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUntagResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpAssociateAdminAccountValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAssociateAdminAccount{}, middleware.After)
}
func addOpAssociateThirdPartyFirewallValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAssociateThirdPartyFirewall{}, middleware.After)
}
func addOpBatchAssociateResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpBatchAssociateResource{}, middleware.After)
}
func addOpBatchDisassociateResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpBatchDisassociateResource{}, middleware.After)
}
func addOpDeleteAppsListValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteAppsList{}, middleware.After)
}
func addOpDeletePolicyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeletePolicy{}, middleware.After)
}
func addOpDeleteProtocolsListValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteProtocolsList{}, middleware.After)
}
func addOpDeleteResourceSetValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteResourceSet{}, middleware.After)
}
func addOpDisassociateThirdPartyFirewallValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDisassociateThirdPartyFirewall{}, middleware.After)
}
func addOpGetAdminScopeValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetAdminScope{}, middleware.After)
}
func addOpGetAppsListValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetAppsList{}, middleware.After)
}
func addOpGetComplianceDetailValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetComplianceDetail{}, middleware.After)
}
func addOpGetPolicyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetPolicy{}, middleware.After)
}
func addOpGetProtectionStatusValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetProtectionStatus{}, middleware.After)
}
func addOpGetProtocolsListValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetProtocolsList{}, middleware.After)
}
func addOpGetResourceSetValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetResourceSet{}, middleware.After)
}
func addOpGetThirdPartyFirewallAssociationStatusValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetThirdPartyFirewallAssociationStatus{}, middleware.After)
}
func addOpGetViolationDetailsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpGetViolationDetails{}, middleware.After)
}
func addOpListAppsListsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListAppsLists{}, middleware.After)
}
func addOpListComplianceStatusValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListComplianceStatus{}, middleware.After)
}
func addOpListDiscoveredResourcesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListDiscoveredResources{}, middleware.After)
}
func addOpListProtocolsListsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListProtocolsLists{}, middleware.After)
}
func addOpListResourceSetResourcesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListResourceSetResources{}, middleware.After)
}
func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
}
func addOpListThirdPartyFirewallFirewallPoliciesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListThirdPartyFirewallFirewallPolicies{}, middleware.After)
}
func addOpPutAdminAccountValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpPutAdminAccount{}, middleware.After)
}
func addOpPutAppsListValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpPutAppsList{}, middleware.After)
}
func addOpPutNotificationChannelValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpPutNotificationChannel{}, middleware.After)
}
func addOpPutPolicyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpPutPolicy{}, middleware.After)
}
func addOpPutProtocolsListValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpPutProtocolsList{}, middleware.After)
}
func addOpPutResourceSetValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpPutResourceSet{}, 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 validateApp(v *types.App) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "App"}
if v.AppName == nil {
invalidParams.Add(smithy.NewErrParamRequired("AppName"))
}
if v.Protocol == nil {
invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
}
if v.Port == nil {
invalidParams.Add(smithy.NewErrParamRequired("Port"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAppsList(v []types.App) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AppsList"}
for i := range v {
if err := validateApp(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAppsListData(v *types.AppsListData) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AppsListData"}
if v.ListName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ListName"))
}
if v.AppsList == nil {
invalidParams.Add(smithy.NewErrParamRequired("AppsList"))
} else if v.AppsList != nil {
if err := validateAppsList(v.AppsList); err != nil {
invalidParams.AddNested("AppsList", err.(smithy.InvalidParamsError))
}
}
if v.PreviousAppsList != nil {
if err := validatePreviousAppsList(v.PreviousAppsList); err != nil {
invalidParams.AddNested("PreviousAppsList", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validatePolicy(v *types.Policy) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Policy"}
if v.PolicyName == nil {
invalidParams.Add(smithy.NewErrParamRequired("PolicyName"))
}
if v.SecurityServicePolicyData == nil {
invalidParams.Add(smithy.NewErrParamRequired("SecurityServicePolicyData"))
} else if v.SecurityServicePolicyData != nil {
if err := validateSecurityServicePolicyData(v.SecurityServicePolicyData); err != nil {
invalidParams.AddNested("SecurityServicePolicyData", err.(smithy.InvalidParamsError))
}
}
if v.ResourceType == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
}
if v.ResourceTags != nil {
if err := validateResourceTags(v.ResourceTags); err != nil {
invalidParams.AddNested("ResourceTags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validatePreviousAppsList(v map[string][]types.App) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PreviousAppsList"}
for key := range v {
if err := validateAppsList(v[key]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateProtocolsListData(v *types.ProtocolsListData) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ProtocolsListData"}
if v.ListName == nil {
invalidParams.Add(smithy.NewErrParamRequired("ListName"))
}
if v.ProtocolsList == nil {
invalidParams.Add(smithy.NewErrParamRequired("ProtocolsList"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateResourceSet(v *types.ResourceSet) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ResourceSet"}
if v.Name == nil {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.ResourceTypeList == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceTypeList"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateResourceTag(v *types.ResourceTag) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ResourceTag"}
if v.Key == nil {
invalidParams.Add(smithy.NewErrParamRequired("Key"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateResourceTags(v []types.ResourceTag) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ResourceTags"}
for i := range v {
if err := validateResourceTag(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateSecurityServicePolicyData(v *types.SecurityServicePolicyData) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SecurityServicePolicyData"}
if len(v.Type) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Type"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTag(v *types.Tag) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Tag"}
if v.Key == nil {
invalidParams.Add(smithy.NewErrParamRequired("Key"))
}
if v.Value == nil {
invalidParams.Add(smithy.NewErrParamRequired("Value"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTagList(v []types.Tag) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "TagList"}
for i := range v {
if err := validateTag(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAssociateAdminAccountInput(v *AssociateAdminAccountInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AssociateAdminAccountInput"}
if v.AdminAccount == nil {
invalidParams.Add(smithy.NewErrParamRequired("AdminAccount"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAssociateThirdPartyFirewallInput(v *AssociateThirdPartyFirewallInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AssociateThirdPartyFirewallInput"}
if len(v.ThirdPartyFirewall) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ThirdPartyFirewall"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpBatchAssociateResourceInput(v *BatchAssociateResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchAssociateResourceInput"}
if v.ResourceSetIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceSetIdentifier"))
}
if v.Items == nil {
invalidParams.Add(smithy.NewErrParamRequired("Items"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpBatchDisassociateResourceInput(v *BatchDisassociateResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BatchDisassociateResourceInput"}
if v.ResourceSetIdentifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceSetIdentifier"))
}
if v.Items == nil {
invalidParams.Add(smithy.NewErrParamRequired("Items"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteAppsListInput(v *DeleteAppsListInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteAppsListInput"}
if v.ListId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ListId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeletePolicyInput(v *DeletePolicyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeletePolicyInput"}
if v.PolicyId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PolicyId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteProtocolsListInput(v *DeleteProtocolsListInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteProtocolsListInput"}
if v.ListId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ListId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteResourceSetInput(v *DeleteResourceSetInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteResourceSetInput"}
if v.Identifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDisassociateThirdPartyFirewallInput(v *DisassociateThirdPartyFirewallInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DisassociateThirdPartyFirewallInput"}
if len(v.ThirdPartyFirewall) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ThirdPartyFirewall"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetAdminScopeInput(v *GetAdminScopeInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetAdminScopeInput"}
if v.AdminAccount == nil {
invalidParams.Add(smithy.NewErrParamRequired("AdminAccount"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetAppsListInput(v *GetAppsListInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetAppsListInput"}
if v.ListId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ListId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetComplianceDetailInput(v *GetComplianceDetailInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetComplianceDetailInput"}
if v.PolicyId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PolicyId"))
}
if v.MemberAccount == nil {
invalidParams.Add(smithy.NewErrParamRequired("MemberAccount"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetPolicyInput(v *GetPolicyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetPolicyInput"}
if v.PolicyId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PolicyId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetProtectionStatusInput(v *GetProtectionStatusInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetProtectionStatusInput"}
if v.PolicyId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PolicyId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetProtocolsListInput(v *GetProtocolsListInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetProtocolsListInput"}
if v.ListId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ListId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetResourceSetInput(v *GetResourceSetInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetResourceSetInput"}
if v.Identifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetThirdPartyFirewallAssociationStatusInput(v *GetThirdPartyFirewallAssociationStatusInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetThirdPartyFirewallAssociationStatusInput"}
if len(v.ThirdPartyFirewall) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ThirdPartyFirewall"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpGetViolationDetailsInput(v *GetViolationDetailsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "GetViolationDetailsInput"}
if v.PolicyId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PolicyId"))
}
if v.MemberAccount == nil {
invalidParams.Add(smithy.NewErrParamRequired("MemberAccount"))
}
if v.ResourceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
}
if v.ResourceType == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListAppsListsInput(v *ListAppsListsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListAppsListsInput"}
if v.MaxResults == nil {
invalidParams.Add(smithy.NewErrParamRequired("MaxResults"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListComplianceStatusInput(v *ListComplianceStatusInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListComplianceStatusInput"}
if v.PolicyId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PolicyId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListDiscoveredResourcesInput(v *ListDiscoveredResourcesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListDiscoveredResourcesInput"}
if v.MemberAccountIds == nil {
invalidParams.Add(smithy.NewErrParamRequired("MemberAccountIds"))
}
if v.ResourceType == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListProtocolsListsInput(v *ListProtocolsListsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListProtocolsListsInput"}
if v.MaxResults == nil {
invalidParams.Add(smithy.NewErrParamRequired("MaxResults"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListResourceSetResourcesInput(v *ListResourceSetResourcesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListResourceSetResourcesInput"}
if v.Identifier == nil {
invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
}
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 validateOpListThirdPartyFirewallFirewallPoliciesInput(v *ListThirdPartyFirewallFirewallPoliciesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListThirdPartyFirewallFirewallPoliciesInput"}
if len(v.ThirdPartyFirewall) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("ThirdPartyFirewall"))
}
if v.MaxResults == nil {
invalidParams.Add(smithy.NewErrParamRequired("MaxResults"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpPutAdminAccountInput(v *PutAdminAccountInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PutAdminAccountInput"}
if v.AdminAccount == nil {
invalidParams.Add(smithy.NewErrParamRequired("AdminAccount"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpPutAppsListInput(v *PutAppsListInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PutAppsListInput"}
if v.AppsList == nil {
invalidParams.Add(smithy.NewErrParamRequired("AppsList"))
} else if v.AppsList != nil {
if err := validateAppsListData(v.AppsList); err != nil {
invalidParams.AddNested("AppsList", err.(smithy.InvalidParamsError))
}
}
if v.TagList != nil {
if err := validateTagList(v.TagList); err != nil {
invalidParams.AddNested("TagList", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpPutNotificationChannelInput(v *PutNotificationChannelInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PutNotificationChannelInput"}
if v.SnsTopicArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("SnsTopicArn"))
}
if v.SnsRoleName == nil {
invalidParams.Add(smithy.NewErrParamRequired("SnsRoleName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpPutPolicyInput(v *PutPolicyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PutPolicyInput"}
if v.Policy == nil {
invalidParams.Add(smithy.NewErrParamRequired("Policy"))
} else if v.Policy != nil {
if err := validatePolicy(v.Policy); err != nil {
invalidParams.AddNested("Policy", err.(smithy.InvalidParamsError))
}
}
if v.TagList != nil {
if err := validateTagList(v.TagList); err != nil {
invalidParams.AddNested("TagList", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpPutProtocolsListInput(v *PutProtocolsListInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PutProtocolsListInput"}
if v.ProtocolsList == nil {
invalidParams.Add(smithy.NewErrParamRequired("ProtocolsList"))
} else if v.ProtocolsList != nil {
if err := validateProtocolsListData(v.ProtocolsList); err != nil {
invalidParams.AddNested("ProtocolsList", err.(smithy.InvalidParamsError))
}
}
if v.TagList != nil {
if err := validateTagList(v.TagList); err != nil {
invalidParams.AddNested("TagList", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpPutResourceSetInput(v *PutResourceSetInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "PutResourceSetInput"}
if v.ResourceSet == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceSet"))
} else if v.ResourceSet != nil {
if err := validateResourceSet(v.ResourceSet); err != nil {
invalidParams.AddNested("ResourceSet", err.(smithy.InvalidParamsError))
}
}
if v.TagList != nil {
if err := validateTagList(v.TagList); err != nil {
invalidParams.AddNested("TagList", 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.TagList == nil {
invalidParams.Add(smithy.NewErrParamRequired("TagList"))
} else if v.TagList != nil {
if err := validateTagList(v.TagList); err != nil {
invalidParams.AddNested("TagList", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUntagResourceInput(v *UntagResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
if v.ResourceArn == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
}
if v.TagKeys == nil {
invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
| 1,602 |
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 FMS 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: "fms.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "fms-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "fms.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.Aws,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "af-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "af-south-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.af-south-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "ap-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-east-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.ap-east-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "ap-northeast-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-northeast-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.ap-northeast-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "ap-northeast-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-northeast-2",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.ap-northeast-2.amazonaws.com",
},
endpoints.EndpointKey{
Region: "ap-northeast-3",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-south-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.ap-south-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "ap-south-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.ap-southeast-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "ap-southeast-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-2",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.ap-southeast-2.amazonaws.com",
},
endpoints.EndpointKey{
Region: "ap-southeast-3",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ap-southeast-4",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ca-central-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "ca-central-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.ca-central-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "eu-central-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-central-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.eu-central-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "eu-central-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-north-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-south-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.eu-south-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "eu-south-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.eu-west-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "eu-west-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-2",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.eu-west-2.amazonaws.com",
},
endpoints.EndpointKey{
Region: "eu-west-3",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "eu-west-3",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.eu-west-3.amazonaws.com",
},
endpoints.EndpointKey{
Region: "fips-af-south-1",
}: endpoints.Endpoint{
Hostname: "fms-fips.af-south-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "af-south-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-ap-east-1",
}: endpoints.Endpoint{
Hostname: "fms-fips.ap-east-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "ap-east-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-ap-northeast-1",
}: endpoints.Endpoint{
Hostname: "fms-fips.ap-northeast-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "ap-northeast-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-ap-northeast-2",
}: endpoints.Endpoint{
Hostname: "fms-fips.ap-northeast-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "ap-northeast-2",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-ap-south-1",
}: endpoints.Endpoint{
Hostname: "fms-fips.ap-south-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "ap-south-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-ap-southeast-1",
}: endpoints.Endpoint{
Hostname: "fms-fips.ap-southeast-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "ap-southeast-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-ap-southeast-2",
}: endpoints.Endpoint{
Hostname: "fms-fips.ap-southeast-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "ap-southeast-2",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-ca-central-1",
}: endpoints.Endpoint{
Hostname: "fms-fips.ca-central-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "ca-central-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-eu-central-1",
}: endpoints.Endpoint{
Hostname: "fms-fips.eu-central-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "eu-central-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-eu-south-1",
}: endpoints.Endpoint{
Hostname: "fms-fips.eu-south-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "eu-south-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-eu-west-1",
}: endpoints.Endpoint{
Hostname: "fms-fips.eu-west-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "eu-west-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-eu-west-2",
}: endpoints.Endpoint{
Hostname: "fms-fips.eu-west-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "eu-west-2",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-eu-west-3",
}: endpoints.Endpoint{
Hostname: "fms-fips.eu-west-3.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "eu-west-3",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-me-south-1",
}: endpoints.Endpoint{
Hostname: "fms-fips.me-south-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "me-south-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-sa-east-1",
}: endpoints.Endpoint{
Hostname: "fms-fips.sa-east-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "sa-east-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-us-east-1",
}: endpoints.Endpoint{
Hostname: "fms-fips.us-east-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-east-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-us-east-2",
}: endpoints.Endpoint{
Hostname: "fms-fips.us-east-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-east-2",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-us-west-1",
}: endpoints.Endpoint{
Hostname: "fms-fips.us-west-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-west-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-us-west-2",
}: endpoints.Endpoint{
Hostname: "fms-fips.us-west-2.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-west-2",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "me-central-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "me-south-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "me-south-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.me-south-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "sa-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "sa-east-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.sa-east-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-east-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.us-east-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-east-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-east-2",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.us-east-2.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-west-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.us-west-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-west-2",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-west-2",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.us-west-2.amazonaws.com",
},
},
},
{
ID: "aws-cn",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.DualStackVariant,
}: {
Hostname: "fms.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "fms-fips.{region}.api.amazonwebservices.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "fms.{region}.amazonaws.com.cn",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsCn,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "cn-north-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "cn-northwest-1",
}: endpoints.Endpoint{},
},
},
{
ID: "aws-iso",
Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.{region}.c2s.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "fms.{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: "fms-fips.{region}.sc2s.sgov.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "fms.{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: "fms-fips.{region}.cloud.adc-e.uk",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "fms.{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: "fms-fips.{region}.csp.hci.ic.gov",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "fms.{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: "fms.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: endpoints.FIPSVariant | endpoints.DualStackVariant,
}: {
Hostname: "fms-fips.{region}.api.aws",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
{
Variant: 0,
}: {
Hostname: "fms.{region}.amazonaws.com",
Protocols: []string{"https"},
SignatureVersions: []string{"v4"},
},
},
RegionRegex: partitionRegexp.AwsUsGov,
IsRegionalized: true,
Endpoints: endpoints.Endpoints{
endpoints.EndpointKey{
Region: "fips-us-gov-east-1",
}: endpoints.Endpoint{
Hostname: "fms-fips.us-gov-east-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-gov-east-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "fips-us-gov-west-1",
}: endpoints.Endpoint{
Hostname: "fms-fips.us-gov-west-1.amazonaws.com",
CredentialScope: endpoints.CredentialScope{
Region: "us-gov-west-1",
},
Deprecated: aws.TrueTernary,
},
endpoints.EndpointKey{
Region: "us-gov-east-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-gov-east-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.us-gov-east-1.amazonaws.com",
},
endpoints.EndpointKey{
Region: "us-gov-west-1",
}: endpoints.Endpoint{},
endpoints.EndpointKey{
Region: "us-gov-west-1",
Variant: endpoints.FIPSVariant,
}: {
Hostname: "fms-fips.us-gov-west-1.amazonaws.com",
},
},
},
}
| 711 |
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 AccountRoleStatus string
// Enum values for AccountRoleStatus
const (
AccountRoleStatusReady AccountRoleStatus = "READY"
AccountRoleStatusCreating AccountRoleStatus = "CREATING"
AccountRoleStatusPendingDeletion AccountRoleStatus = "PENDING_DELETION"
AccountRoleStatusDeleting AccountRoleStatus = "DELETING"
AccountRoleStatusDeleted AccountRoleStatus = "DELETED"
)
// Values returns all known values for AccountRoleStatus. 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 (AccountRoleStatus) Values() []AccountRoleStatus {
return []AccountRoleStatus{
"READY",
"CREATING",
"PENDING_DELETION",
"DELETING",
"DELETED",
}
}
type CustomerPolicyScopeIdType string
// Enum values for CustomerPolicyScopeIdType
const (
CustomerPolicyScopeIdTypeAccount CustomerPolicyScopeIdType = "ACCOUNT"
CustomerPolicyScopeIdTypeOrgUnit CustomerPolicyScopeIdType = "ORG_UNIT"
)
// Values returns all known values for CustomerPolicyScopeIdType. 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 (CustomerPolicyScopeIdType) Values() []CustomerPolicyScopeIdType {
return []CustomerPolicyScopeIdType{
"ACCOUNT",
"ORG_UNIT",
}
}
type CustomerPolicyStatus string
// Enum values for CustomerPolicyStatus
const (
CustomerPolicyStatusActive CustomerPolicyStatus = "ACTIVE"
CustomerPolicyStatusOutOfAdminScope CustomerPolicyStatus = "OUT_OF_ADMIN_SCOPE"
)
// Values returns all known values for CustomerPolicyStatus. 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 (CustomerPolicyStatus) Values() []CustomerPolicyStatus {
return []CustomerPolicyStatus{
"ACTIVE",
"OUT_OF_ADMIN_SCOPE",
}
}
type DependentServiceName string
// Enum values for DependentServiceName
const (
DependentServiceNameAWSConfig DependentServiceName = "AWSCONFIG"
DependentServiceNameAwswaf DependentServiceName = "AWSWAF"
DependentServiceNameAWSShieldAdvanced DependentServiceName = "AWSSHIELD_ADVANCED"
DependentServiceNameAWSVirtualPrivateCloud DependentServiceName = "AWSVPC"
)
// Values returns all known values for DependentServiceName. 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 (DependentServiceName) Values() []DependentServiceName {
return []DependentServiceName{
"AWSCONFIG",
"AWSWAF",
"AWSSHIELD_ADVANCED",
"AWSVPC",
}
}
type DestinationType string
// Enum values for DestinationType
const (
DestinationTypeIpv4 DestinationType = "IPV4"
DestinationTypeIpv6 DestinationType = "IPV6"
DestinationTypePrefixList DestinationType = "PREFIX_LIST"
)
// Values returns all known values for DestinationType. 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 (DestinationType) Values() []DestinationType {
return []DestinationType{
"IPV4",
"IPV6",
"PREFIX_LIST",
}
}
type FailedItemReason string
// Enum values for FailedItemReason
const (
FailedItemReasonNotValidArn FailedItemReason = "NOT_VALID_ARN"
FailedItemReasonNotValidPartition FailedItemReason = "NOT_VALID_PARTITION"
FailedItemReasonNotValidRegion FailedItemReason = "NOT_VALID_REGION"
FailedItemReasonNotValidService FailedItemReason = "NOT_VALID_SERVICE"
FailedItemReasonNotValidResourceType FailedItemReason = "NOT_VALID_RESOURCE_TYPE"
FailedItemReasonNotValidAccountId FailedItemReason = "NOT_VALID_ACCOUNT_ID"
)
// Values returns all known values for FailedItemReason. 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 (FailedItemReason) Values() []FailedItemReason {
return []FailedItemReason{
"NOT_VALID_ARN",
"NOT_VALID_PARTITION",
"NOT_VALID_REGION",
"NOT_VALID_SERVICE",
"NOT_VALID_RESOURCE_TYPE",
"NOT_VALID_ACCOUNT_ID",
}
}
type FirewallDeploymentModel string
// Enum values for FirewallDeploymentModel
const (
FirewallDeploymentModelCentralized FirewallDeploymentModel = "CENTRALIZED"
FirewallDeploymentModelDistributed FirewallDeploymentModel = "DISTRIBUTED"
)
// Values returns all known values for FirewallDeploymentModel. 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 (FirewallDeploymentModel) Values() []FirewallDeploymentModel {
return []FirewallDeploymentModel{
"CENTRALIZED",
"DISTRIBUTED",
}
}
type MarketplaceSubscriptionOnboardingStatus string
// Enum values for MarketplaceSubscriptionOnboardingStatus
const (
MarketplaceSubscriptionOnboardingStatusNoSubscription MarketplaceSubscriptionOnboardingStatus = "NO_SUBSCRIPTION"
MarketplaceSubscriptionOnboardingStatusNotComplete MarketplaceSubscriptionOnboardingStatus = "NOT_COMPLETE"
MarketplaceSubscriptionOnboardingStatusComplete MarketplaceSubscriptionOnboardingStatus = "COMPLETE"
)
// Values returns all known values for MarketplaceSubscriptionOnboardingStatus.
// 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 (MarketplaceSubscriptionOnboardingStatus) Values() []MarketplaceSubscriptionOnboardingStatus {
return []MarketplaceSubscriptionOnboardingStatus{
"NO_SUBSCRIPTION",
"NOT_COMPLETE",
"COMPLETE",
}
}
type NetworkFirewallOverrideAction string
// Enum values for NetworkFirewallOverrideAction
const (
NetworkFirewallOverrideActionDropToAlert NetworkFirewallOverrideAction = "DROP_TO_ALERT"
)
// Values returns all known values for NetworkFirewallOverrideAction. 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 (NetworkFirewallOverrideAction) Values() []NetworkFirewallOverrideAction {
return []NetworkFirewallOverrideAction{
"DROP_TO_ALERT",
}
}
type OrganizationStatus string
// Enum values for OrganizationStatus
const (
OrganizationStatusOnboarding OrganizationStatus = "ONBOARDING"
OrganizationStatusOnboardingComplete OrganizationStatus = "ONBOARDING_COMPLETE"
OrganizationStatusOffboarding OrganizationStatus = "OFFBOARDING"
OrganizationStatusOffboardingComplete OrganizationStatus = "OFFBOARDING_COMPLETE"
)
// Values returns all known values for OrganizationStatus. 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 (OrganizationStatus) Values() []OrganizationStatus {
return []OrganizationStatus{
"ONBOARDING",
"ONBOARDING_COMPLETE",
"OFFBOARDING",
"OFFBOARDING_COMPLETE",
}
}
type PolicyComplianceStatusType string
// Enum values for PolicyComplianceStatusType
const (
PolicyComplianceStatusTypeCompliant PolicyComplianceStatusType = "COMPLIANT"
PolicyComplianceStatusTypeNonCompliant PolicyComplianceStatusType = "NON_COMPLIANT"
)
// Values returns all known values for PolicyComplianceStatusType. 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 (PolicyComplianceStatusType) Values() []PolicyComplianceStatusType {
return []PolicyComplianceStatusType{
"COMPLIANT",
"NON_COMPLIANT",
}
}
type RemediationActionType string
// Enum values for RemediationActionType
const (
RemediationActionTypeRemove RemediationActionType = "REMOVE"
RemediationActionTypeModify RemediationActionType = "MODIFY"
)
// Values returns all known values for RemediationActionType. 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 (RemediationActionType) Values() []RemediationActionType {
return []RemediationActionType{
"REMOVE",
"MODIFY",
}
}
type ResourceSetStatus string
// Enum values for ResourceSetStatus
const (
ResourceSetStatusActive ResourceSetStatus = "ACTIVE"
ResourceSetStatusOutOfAdminScope ResourceSetStatus = "OUT_OF_ADMIN_SCOPE"
)
// Values returns all known values for ResourceSetStatus. 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 (ResourceSetStatus) Values() []ResourceSetStatus {
return []ResourceSetStatus{
"ACTIVE",
"OUT_OF_ADMIN_SCOPE",
}
}
type RuleOrder string
// Enum values for RuleOrder
const (
RuleOrderStrictOrder RuleOrder = "STRICT_ORDER"
RuleOrderDefaultActionOrder RuleOrder = "DEFAULT_ACTION_ORDER"
)
// Values returns all known values for RuleOrder. 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 (RuleOrder) Values() []RuleOrder {
return []RuleOrder{
"STRICT_ORDER",
"DEFAULT_ACTION_ORDER",
}
}
type SecurityServiceType string
// Enum values for SecurityServiceType
const (
SecurityServiceTypeWaf SecurityServiceType = "WAF"
SecurityServiceTypeWafv2 SecurityServiceType = "WAFV2"
SecurityServiceTypeShieldAdvanced SecurityServiceType = "SHIELD_ADVANCED"
SecurityServiceTypeSecurityGroupsCommon SecurityServiceType = "SECURITY_GROUPS_COMMON"
SecurityServiceTypeSecurityGroupsContentAudit SecurityServiceType = "SECURITY_GROUPS_CONTENT_AUDIT"
SecurityServiceTypeSecurityGroupsUsageAudit SecurityServiceType = "SECURITY_GROUPS_USAGE_AUDIT"
SecurityServiceTypeNetworkFirewall SecurityServiceType = "NETWORK_FIREWALL"
SecurityServiceTypeDnsFirewall SecurityServiceType = "DNS_FIREWALL"
SecurityServiceTypeThirdPartyFirewall SecurityServiceType = "THIRD_PARTY_FIREWALL"
SecurityServiceTypeImportNetworkFirewall SecurityServiceType = "IMPORT_NETWORK_FIREWALL"
)
// Values returns all known values for SecurityServiceType. 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 (SecurityServiceType) Values() []SecurityServiceType {
return []SecurityServiceType{
"WAF",
"WAFV2",
"SHIELD_ADVANCED",
"SECURITY_GROUPS_COMMON",
"SECURITY_GROUPS_CONTENT_AUDIT",
"SECURITY_GROUPS_USAGE_AUDIT",
"NETWORK_FIREWALL",
"DNS_FIREWALL",
"THIRD_PARTY_FIREWALL",
"IMPORT_NETWORK_FIREWALL",
}
}
type TargetType string
// Enum values for TargetType
const (
TargetTypeGateway TargetType = "GATEWAY"
TargetTypeCarrierGateway TargetType = "CARRIER_GATEWAY"
TargetTypeInstance TargetType = "INSTANCE"
TargetTypeLocalGateway TargetType = "LOCAL_GATEWAY"
TargetTypeNatGateway TargetType = "NAT_GATEWAY"
TargetTypeNetworkInterface TargetType = "NETWORK_INTERFACE"
TargetTypeVPCEndpoint TargetType = "VPC_ENDPOINT"
TargetTypeVPCPeeringConnection TargetType = "VPC_PEERING_CONNECTION"
TargetTypeEgressOnlyInternetGateway TargetType = "EGRESS_ONLY_INTERNET_GATEWAY"
TargetTypeTransitGateway TargetType = "TRANSIT_GATEWAY"
)
// Values returns all known values for TargetType. 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 (TargetType) Values() []TargetType {
return []TargetType{
"GATEWAY",
"CARRIER_GATEWAY",
"INSTANCE",
"LOCAL_GATEWAY",
"NAT_GATEWAY",
"NETWORK_INTERFACE",
"VPC_ENDPOINT",
"VPC_PEERING_CONNECTION",
"EGRESS_ONLY_INTERNET_GATEWAY",
"TRANSIT_GATEWAY",
}
}
type ThirdPartyFirewall string
// Enum values for ThirdPartyFirewall
const (
ThirdPartyFirewallPaloAltoNetworksCloudNgfw ThirdPartyFirewall = "PALO_ALTO_NETWORKS_CLOUD_NGFW"
ThirdPartyFirewallFortigateCloudNativeFirewall ThirdPartyFirewall = "FORTIGATE_CLOUD_NATIVE_FIREWALL"
)
// Values returns all known values for ThirdPartyFirewall. 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 (ThirdPartyFirewall) Values() []ThirdPartyFirewall {
return []ThirdPartyFirewall{
"PALO_ALTO_NETWORKS_CLOUD_NGFW",
"FORTIGATE_CLOUD_NATIVE_FIREWALL",
}
}
type ThirdPartyFirewallAssociationStatus string
// Enum values for ThirdPartyFirewallAssociationStatus
const (
ThirdPartyFirewallAssociationStatusOnboarding ThirdPartyFirewallAssociationStatus = "ONBOARDING"
ThirdPartyFirewallAssociationStatusOnboardComplete ThirdPartyFirewallAssociationStatus = "ONBOARD_COMPLETE"
ThirdPartyFirewallAssociationStatusOffboarding ThirdPartyFirewallAssociationStatus = "OFFBOARDING"
ThirdPartyFirewallAssociationStatusOffboardComplete ThirdPartyFirewallAssociationStatus = "OFFBOARD_COMPLETE"
ThirdPartyFirewallAssociationStatusNotExist ThirdPartyFirewallAssociationStatus = "NOT_EXIST"
)
// Values returns all known values for ThirdPartyFirewallAssociationStatus. 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 (ThirdPartyFirewallAssociationStatus) Values() []ThirdPartyFirewallAssociationStatus {
return []ThirdPartyFirewallAssociationStatus{
"ONBOARDING",
"ONBOARD_COMPLETE",
"OFFBOARDING",
"OFFBOARD_COMPLETE",
"NOT_EXIST",
}
}
type ViolationReason string
// Enum values for ViolationReason
const (
ViolationReasonWebAclMissingRuleGroup ViolationReason = "WEB_ACL_MISSING_RULE_GROUP"
ViolationReasonResourceMissingWebAcl ViolationReason = "RESOURCE_MISSING_WEB_ACL"
ViolationReasonResourceIncorrectWebAcl ViolationReason = "RESOURCE_INCORRECT_WEB_ACL"
ViolationReasonResourceMissingShieldProtection ViolationReason = "RESOURCE_MISSING_SHIELD_PROTECTION"
ViolationReasonResourceMissingWebaclOrShieldProtection ViolationReason = "RESOURCE_MISSING_WEB_ACL_OR_SHIELD_PROTECTION"
ViolationReasonResourceMissingSecurityGroup ViolationReason = "RESOURCE_MISSING_SECURITY_GROUP"
ViolationReasonResourceViolatesAuditSecurityGroup ViolationReason = "RESOURCE_VIOLATES_AUDIT_SECURITY_GROUP"
ViolationReasonSecurityGroupUnused ViolationReason = "SECURITY_GROUP_UNUSED"
ViolationReasonSecurityGroupRedundant ViolationReason = "SECURITY_GROUP_REDUNDANT"
ViolationReasonFMSCreatedSecurityGroupEdited ViolationReason = "FMS_CREATED_SECURITY_GROUP_EDITED"
ViolationReasonMissingFirewall ViolationReason = "MISSING_FIREWALL"
ViolationReasonMissingFirewallSubnetInAZ ViolationReason = "MISSING_FIREWALL_SUBNET_IN_AZ"
ViolationReasonMissingExpectedRouteTable ViolationReason = "MISSING_EXPECTED_ROUTE_TABLE"
ViolationReasonNetworkFirewallPolicyModified ViolationReason = "NETWORK_FIREWALL_POLICY_MODIFIED"
ViolationReasonFirewallSubnetIsOutOfScope ViolationReason = "FIREWALL_SUBNET_IS_OUT_OF_SCOPE"
ViolationReasonInternetGatewayMissingExpectedRoute ViolationReason = "INTERNET_GATEWAY_MISSING_EXPECTED_ROUTE"
ViolationReasonFirewallSubnetMissingExpectedRoute ViolationReason = "FIREWALL_SUBNET_MISSING_EXPECTED_ROUTE"
ViolationReasonUnexpectedFirewallRoutes ViolationReason = "UNEXPECTED_FIREWALL_ROUTES"
ViolationReasonUnexpectedTargetGatewayRoutes ViolationReason = "UNEXPECTED_TARGET_GATEWAY_ROUTES"
ViolationReasonTrafficInspectionCrossesAZBoundary ViolationReason = "TRAFFIC_INSPECTION_CROSSES_AZ_BOUNDARY"
ViolationReasonInvalidRouteConfiguration ViolationReason = "INVALID_ROUTE_CONFIGURATION"
ViolationReasonMissingTargetGateway ViolationReason = "MISSING_TARGET_GATEWAY"
ViolationReasonInternetTrafficNotInspected ViolationReason = "INTERNET_TRAFFIC_NOT_INSPECTED"
ViolationReasonBlackHoleRouteDetected ViolationReason = "BLACK_HOLE_ROUTE_DETECTED"
ViolationReasonBlackHoleRouteDetectedInFirewallSubnet ViolationReason = "BLACK_HOLE_ROUTE_DETECTED_IN_FIREWALL_SUBNET"
ViolationReasonResourceMissingDnsFirewall ViolationReason = "RESOURCE_MISSING_DNS_FIREWALL"
ViolationReasonRouteHasOutOfScopeEndpoint ViolationReason = "ROUTE_HAS_OUT_OF_SCOPE_ENDPOINT"
ViolationReasonFirewallSubnetMissingVPCEndpoint ViolationReason = "FIREWALL_SUBNET_MISSING_VPCE_ENDPOINT"
)
// Values returns all known values for ViolationReason. 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 (ViolationReason) Values() []ViolationReason {
return []ViolationReason{
"WEB_ACL_MISSING_RULE_GROUP",
"RESOURCE_MISSING_WEB_ACL",
"RESOURCE_INCORRECT_WEB_ACL",
"RESOURCE_MISSING_SHIELD_PROTECTION",
"RESOURCE_MISSING_WEB_ACL_OR_SHIELD_PROTECTION",
"RESOURCE_MISSING_SECURITY_GROUP",
"RESOURCE_VIOLATES_AUDIT_SECURITY_GROUP",
"SECURITY_GROUP_UNUSED",
"SECURITY_GROUP_REDUNDANT",
"FMS_CREATED_SECURITY_GROUP_EDITED",
"MISSING_FIREWALL",
"MISSING_FIREWALL_SUBNET_IN_AZ",
"MISSING_EXPECTED_ROUTE_TABLE",
"NETWORK_FIREWALL_POLICY_MODIFIED",
"FIREWALL_SUBNET_IS_OUT_OF_SCOPE",
"INTERNET_GATEWAY_MISSING_EXPECTED_ROUTE",
"FIREWALL_SUBNET_MISSING_EXPECTED_ROUTE",
"UNEXPECTED_FIREWALL_ROUTES",
"UNEXPECTED_TARGET_GATEWAY_ROUTES",
"TRAFFIC_INSPECTION_CROSSES_AZ_BOUNDARY",
"INVALID_ROUTE_CONFIGURATION",
"MISSING_TARGET_GATEWAY",
"INTERNET_TRAFFIC_NOT_INSPECTED",
"BLACK_HOLE_ROUTE_DETECTED",
"BLACK_HOLE_ROUTE_DETECTED_IN_FIREWALL_SUBNET",
"RESOURCE_MISSING_DNS_FIREWALL",
"ROUTE_HAS_OUT_OF_SCOPE_ENDPOINT",
"FIREWALL_SUBNET_MISSING_VPCE_ENDPOINT",
}
}
| 463 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package types
import (
"fmt"
smithy "github.com/aws/smithy-go"
)
// The operation failed because of a system problem, even though the request was
// valid. Retry your request.
type InternalErrorException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InternalErrorException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InternalErrorException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InternalErrorException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InternalErrorException"
}
return *e.ErrorCodeOverride
}
func (e *InternalErrorException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The parameters of the request were invalid.
type InvalidInputException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidInputException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidInputException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidInputException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidInputException"
}
return *e.ErrorCodeOverride
}
func (e *InvalidInputException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The operation failed because there was nothing to do or the operation wasn't
// possible. For example, you might have submitted an AssociateAdminAccount
// request for an account ID that was already set as the Firewall Manager
// administrator. Or you might have tried to access a Region that's disabled by
// default, and that you need to enable for the Firewall Manager administrator
// account and for Organizations before you can access it.
type InvalidOperationException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidOperationException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidOperationException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidOperationException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidOperationException"
}
return *e.ErrorCodeOverride
}
func (e *InvalidOperationException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The value of the Type parameter is invalid.
type InvalidTypeException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *InvalidTypeException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *InvalidTypeException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *InvalidTypeException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "InvalidTypeException"
}
return *e.ErrorCodeOverride
}
func (e *InvalidTypeException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The operation exceeds a resource limit, for example, the maximum number of
// policy objects that you can create for an Amazon Web Services account. For more
// information, see Firewall Manager Limits (https://docs.aws.amazon.com/waf/latest/developerguide/fms-limits.html)
// in the WAF Developer Guide.
type LimitExceededException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *LimitExceededException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *LimitExceededException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *LimitExceededException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "LimitExceededException"
}
return *e.ErrorCodeOverride
}
func (e *LimitExceededException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
// The specified resource was not found.
type ResourceNotFoundException struct {
Message *string
ErrorCodeOverride *string
noSmithyDocumentSerde
}
func (e *ResourceNotFoundException) Error() string {
return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
}
func (e *ResourceNotFoundException) ErrorMessage() string {
if e.Message == nil {
return ""
}
return *e.Message
}
func (e *ResourceNotFoundException) ErrorCode() string {
if e == nil || e.ErrorCodeOverride == nil {
return "ResourceNotFoundException"
}
return *e.ErrorCodeOverride
}
func (e *ResourceNotFoundException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
| 174 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/aws/defaults"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/retry"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources"
smithy "github.com/aws/smithy-go"
smithydocument "github.com/aws/smithy-go/document"
"github.com/aws/smithy-go/logging"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net"
"net/http"
"time"
)
const ServiceID = "forecast"
const ServiceAPIVersion = "2018-06-26"
// Client provides the API client to make operations call for Amazon Forecast
// Service.
type Client struct {
options Options
}
// New returns an initialized Client based on the functional options. Provide
// additional functional options to further configure the behavior of the client,
// such as changing the client's endpoint or adding custom middleware behavior.
func New(options Options, optFns ...func(*Options)) *Client {
options = options.Copy()
resolveDefaultLogger(&options)
setResolvedDefaultsMode(&options)
resolveRetryer(&options)
resolveHTTPClient(&options)
resolveHTTPSignerV4(&options)
resolveDefaultEndpointConfiguration(&options)
for _, fn := range optFns {
fn(&options)
}
client := &Client{
options: options,
}
return client
}
type Options struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// Configures the events that will be sent to the configured logger.
ClientLogMode aws.ClientLogMode
// The credentials object to use when signing requests.
Credentials aws.CredentialsProvider
// The configuration DefaultsMode that the SDK should use when constructing the
// clients initial default settings.
DefaultsMode aws.DefaultsMode
// The endpoint options to be used when attempting to resolve an endpoint.
EndpointOptions EndpointResolverOptions
// The service endpoint resolver.
EndpointResolver EndpointResolver
// Signature Version 4 (SigV4) Signer
HTTPSignerV4 HTTPSignerV4
// The logger writer interface to write logging messages to.
Logger logging.Logger
// The region to send requests to. (Required)
Region string
// RetryMaxAttempts specifies the maximum number attempts an API client will call
// an operation that fails with a retryable error. A value of 0 is ignored, and
// will not be used to configure the API client created default retryer, or modify
// per operation call's retry max attempts. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. If specified in an operation call's functional
// options with a value that is different than the constructed client's Options,
// the Client's Retryer will be wrapped to use the operation's specific
// RetryMaxAttempts value.
RetryMaxAttempts int
// RetryMode specifies the retry mode the API client will be created with, if
// Retryer option is not also specified. When creating a new API Clients this
// member will only be used if the Retryer Options member is nil. This value will
// be ignored if Retryer is not nil. Currently does not support per operation call
// overrides, may in the future.
RetryMode aws.RetryMode
// Retryer guides how HTTP requests should be retried in case of recoverable
// failures. When nil the API client will use a default retryer. The kind of
// default retry created by the API client can be changed with the RetryMode
// option.
Retryer aws.Retryer
// The RuntimeEnvironment configuration, only populated if the DefaultsMode is set
// to DefaultsModeAuto and is initialized using config.LoadDefaultConfig . You
// should not populate this structure programmatically, or rely on the values here
// within your applications.
RuntimeEnvironment aws.RuntimeEnvironment
// The initial DefaultsMode used when the client options were constructed. If the
// DefaultsMode was set to aws.DefaultsModeAuto this will store what the resolved
// value was at that point in time. Currently does not support per operation call
// overrides, may in the future.
resolvedDefaultsMode aws.DefaultsMode
// The HTTP client to invoke API calls with. Defaults to client's default HTTP
// implementation if nil.
HTTPClient HTTPClient
}
// WithAPIOptions returns a functional option for setting the Client's APIOptions
// option.
func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options) {
return func(o *Options) {
o.APIOptions = append(o.APIOptions, optFns...)
}
}
// WithEndpointResolver returns a functional option for setting the Client's
// EndpointResolver option.
func WithEndpointResolver(v EndpointResolver) func(*Options) {
return func(o *Options) {
o.EndpointResolver = v
}
}
type HTTPClient interface {
Do(*http.Request) (*http.Response, error)
}
// Copy creates a clone where the APIOptions list is deep copied.
func (o Options) Copy() Options {
to := o
to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions))
copy(to.APIOptions, o.APIOptions)
return to
}
func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) {
ctx = middleware.ClearStackValues(ctx)
stack := middleware.NewStack(opID, smithyhttp.NewStackRequest)
options := c.options.Copy()
for _, fn := range optFns {
fn(&options)
}
finalizeRetryMaxAttemptOptions(&options, *c)
finalizeClientEndpointResolverOptions(&options)
for _, fn := range stackFns {
if err := fn(stack, options); err != nil {
return nil, metadata, err
}
}
for _, fn := range options.APIOptions {
if err := fn(stack); err != nil {
return nil, metadata, err
}
}
handler := middleware.DecorateHandler(smithyhttp.NewClientHandler(options.HTTPClient), stack)
result, metadata, err = handler.Handle(ctx, params)
if err != nil {
err = &smithy.OperationError{
ServiceID: ServiceID,
OperationName: opID,
Err: err,
}
}
return result, metadata, err
}
type noSmithyDocumentSerde = smithydocument.NoSerde
func resolveDefaultLogger(o *Options) {
if o.Logger != nil {
return
}
o.Logger = logging.Nop{}
}
func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error {
return middleware.AddSetLoggerMiddleware(stack, o.Logger)
}
func setResolvedDefaultsMode(o *Options) {
if len(o.resolvedDefaultsMode) > 0 {
return
}
var mode aws.DefaultsMode
mode.SetFromString(string(o.DefaultsMode))
if mode == aws.DefaultsModeAuto {
mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment)
}
o.resolvedDefaultsMode = mode
}
// NewFromConfig returns a new client from the provided config.
func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client {
opts := Options{
Region: cfg.Region,
DefaultsMode: cfg.DefaultsMode,
RuntimeEnvironment: cfg.RuntimeEnvironment,
HTTPClient: cfg.HTTPClient,
Credentials: cfg.Credentials,
APIOptions: cfg.APIOptions,
Logger: cfg.Logger,
ClientLogMode: cfg.ClientLogMode,
}
resolveAWSRetryerProvider(cfg, &opts)
resolveAWSRetryMaxAttempts(cfg, &opts)
resolveAWSRetryMode(cfg, &opts)
resolveAWSEndpointResolver(cfg, &opts)
resolveUseDualStackEndpoint(cfg, &opts)
resolveUseFIPSEndpoint(cfg, &opts)
return New(opts, optFns...)
}
func resolveHTTPClient(o *Options) {
var buildable *awshttp.BuildableClient
if o.HTTPClient != nil {
var ok bool
buildable, ok = o.HTTPClient.(*awshttp.BuildableClient)
if !ok {
return
}
} else {
buildable = awshttp.NewBuildableClient()
}
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) {
if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok {
dialer.Timeout = dialerTimeout
}
})
buildable = buildable.WithTransportOptions(func(transport *http.Transport) {
if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok {
transport.TLSHandshakeTimeout = tlsHandshakeTimeout
}
})
}
o.HTTPClient = buildable
}
func resolveRetryer(o *Options) {
if o.Retryer != nil {
return
}
if len(o.RetryMode) == 0 {
modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode)
if err == nil {
o.RetryMode = modeConfig.RetryMode
}
}
if len(o.RetryMode) == 0 {
o.RetryMode = aws.RetryModeStandard
}
var standardOptions []func(*retry.StandardOptions)
if v := o.RetryMaxAttempts; v != 0 {
standardOptions = append(standardOptions, func(so *retry.StandardOptions) {
so.MaxAttempts = v
})
}
switch o.RetryMode {
case aws.RetryModeAdaptive:
var adaptiveOptions []func(*retry.AdaptiveModeOptions)
if len(standardOptions) != 0 {
adaptiveOptions = append(adaptiveOptions, func(ao *retry.AdaptiveModeOptions) {
ao.StandardOptions = append(ao.StandardOptions, standardOptions...)
})
}
o.Retryer = retry.NewAdaptiveMode(adaptiveOptions...)
default:
o.Retryer = retry.NewStandard(standardOptions...)
}
}
func resolveAWSRetryerProvider(cfg aws.Config, o *Options) {
if cfg.Retryer == nil {
return
}
o.Retryer = cfg.Retryer()
}
func resolveAWSRetryMode(cfg aws.Config, o *Options) {
if len(cfg.RetryMode) == 0 {
return
}
o.RetryMode = cfg.RetryMode
}
func resolveAWSRetryMaxAttempts(cfg aws.Config, o *Options) {
if cfg.RetryMaxAttempts == 0 {
return
}
o.RetryMaxAttempts = cfg.RetryMaxAttempts
}
func finalizeRetryMaxAttemptOptions(o *Options, client Client) {
if v := o.RetryMaxAttempts; v == 0 || v == client.options.RetryMaxAttempts {
return
}
o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts)
}
func resolveAWSEndpointResolver(cfg aws.Config, o *Options) {
if cfg.EndpointResolver == nil && cfg.EndpointResolverWithOptions == nil {
return
}
o.EndpointResolver = withEndpointResolver(cfg.EndpointResolver, cfg.EndpointResolverWithOptions, NewDefaultEndpointResolver())
}
func addClientUserAgent(stack *middleware.Stack) error {
return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "forecast", goModuleVersion)(stack)
}
func addHTTPSignerV4Middleware(stack *middleware.Stack, o Options) error {
mw := v4.NewSignHTTPRequestMiddleware(v4.SignHTTPRequestMiddlewareOptions{
CredentialsProvider: o.Credentials,
Signer: o.HTTPSignerV4,
LogSigning: o.ClientLogMode.IsSigning(),
})
return stack.Finalize.Add(mw, middleware.After)
}
type HTTPSignerV4 interface {
SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
}
func resolveHTTPSignerV4(o *Options) {
if o.HTTPSignerV4 != nil {
return
}
o.HTTPSignerV4 = newDefaultV4Signer(*o)
}
func newDefaultV4Signer(o Options) *v4.Signer {
return v4.NewSigner(func(so *v4.SignerOptions) {
so.Logger = o.Logger
so.LogSigning = o.ClientLogMode.IsSigning()
})
}
func addRetryMiddlewares(stack *middleware.Stack, o Options) error {
mo := retry.AddRetryMiddlewaresOptions{
Retryer: o.Retryer,
LogRetryAttempts: o.ClientLogMode.IsRetries(),
}
return retry.AddRetryMiddlewares(stack, mo)
}
// resolves dual-stack endpoint configuration
func resolveUseDualStackEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseDualStackEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseDualStackEndpoint = value
}
return nil
}
// resolves FIPS endpoint configuration
func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error {
if len(cfg.ConfigSources) == 0 {
return nil
}
value, found, err := internalConfig.ResolveUseFIPSEndpoint(context.Background(), cfg.ConfigSources)
if err != nil {
return err
}
if found {
o.EndpointOptions.UseFIPSEndpoint = value
}
return nil
}
func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error {
return awsmiddleware.AddRequestIDRetrieverMiddleware(stack)
}
func addResponseErrorMiddleware(stack *middleware.Stack) error {
return awshttp.AddResponseErrorMiddleware(stack)
}
func addRequestResponseLogging(stack *middleware.Stack, o Options) error {
return stack.Deserialize.Add(&smithyhttp.RequestResponseLogger{
LogRequest: o.ClientLogMode.IsRequest(),
LogRequestWithBody: o.ClientLogMode.IsRequestWithBody(),
LogResponse: o.ClientLogMode.IsResponse(),
LogResponseWithBody: o.ClientLogMode.IsResponseWithBody(),
}, middleware.After)
}
| 435 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"io/ioutil"
"net/http"
"strings"
"testing"
)
func TestClient_resolveRetryOptions(t *testing.T) {
nopClient := smithyhttp.ClientDoFunc(func(_ *http.Request) (*http.Response, error) {
return &http.Response{
StatusCode: 200,
Header: http.Header{},
Body: ioutil.NopCloser(strings.NewReader("")),
}, nil
})
cases := map[string]struct {
defaultsMode aws.DefaultsMode
retryer aws.Retryer
retryMaxAttempts int
opRetryMaxAttempts *int
retryMode aws.RetryMode
expectClientRetryMode aws.RetryMode
expectClientMaxAttempts int
expectOpMaxAttempts int
}{
"defaults": {
defaultsMode: aws.DefaultsModeStandard,
expectClientRetryMode: aws.RetryModeStandard,
expectClientMaxAttempts: 3,
expectOpMaxAttempts: 3,
},
"custom default retry": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(2),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 2,
},
"custom op no change max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(10),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
"custom op 0 max attempts": {
retryMode: aws.RetryModeAdaptive,
retryMaxAttempts: 10,
opRetryMaxAttempts: aws.Int(0),
expectClientRetryMode: aws.RetryModeAdaptive,
expectClientMaxAttempts: 10,
expectOpMaxAttempts: 10,
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
client := NewFromConfig(aws.Config{
DefaultsMode: c.defaultsMode,
Retryer: func() func() aws.Retryer {
if c.retryer == nil {
return nil
}
return func() aws.Retryer { return c.retryer }
}(),
HTTPClient: nopClient,
RetryMaxAttempts: c.retryMaxAttempts,
RetryMode: c.retryMode,
})
if e, a := c.expectClientRetryMode, client.options.RetryMode; e != a {
t.Errorf("expect %v retry mode, got %v", e, a)
}
if e, a := c.expectClientMaxAttempts, client.options.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v max attempts, got %v", e, a)
}
_, _, err := client.invokeOperation(context.Background(), "mockOperation", struct{}{},
[]func(*Options){
func(o *Options) {
if c.opRetryMaxAttempts == nil {
return
}
o.RetryMaxAttempts = *c.opRetryMaxAttempts
},
},
func(s *middleware.Stack, o Options) error {
s.Initialize.Clear()
s.Serialize.Clear()
s.Build.Clear()
s.Finalize.Clear()
s.Deserialize.Clear()
if e, a := c.expectOpMaxAttempts, o.Retryer.MaxAttempts(); e != a {
t.Errorf("expect %v op max attempts, got %v", e, a)
}
return nil
})
if err != nil {
t.Fatalf("expect no operation error, got %v", err)
}
})
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an Amazon Forecast predictor. Amazon Forecast creates predictors with
// AutoPredictor, which involves applying the optimal combination of algorithms to
// each time series in your datasets. You can use CreateAutoPredictor to create
// new predictors or upgrade/retrain existing predictors. Creating new predictors
// The following parameters are required when creating a new predictor:
// - PredictorName - A unique name for the predictor.
// - DatasetGroupArn - The ARN of the dataset group used to train the predictor.
// - ForecastFrequency - The granularity of your forecasts (hourly, daily,
// weekly, etc).
// - ForecastHorizon - The number of time-steps that the model predicts. The
// forecast horizon is also called the prediction length.
//
// When creating a new predictor, do not specify a value for ReferencePredictorArn
// . Upgrading and retraining predictors The following parameters are required when
// retraining or upgrading a predictor:
// - PredictorName - A unique name for the predictor.
// - ReferencePredictorArn - The ARN of the predictor to retrain or upgrade.
//
// When upgrading or retraining a predictor, only specify values for the
// ReferencePredictorArn and PredictorName .
func (c *Client) CreateAutoPredictor(ctx context.Context, params *CreateAutoPredictorInput, optFns ...func(*Options)) (*CreateAutoPredictorOutput, error) {
if params == nil {
params = &CreateAutoPredictorInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateAutoPredictor", params, optFns, c.addOperationCreateAutoPredictorMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateAutoPredictorOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateAutoPredictorInput struct {
// A unique name for the predictor
//
// This member is required.
PredictorName *string
// The data configuration for your dataset group and any additional datasets.
DataConfig *types.DataConfig
// An Key Management Service (KMS) key and an Identity and Access Management (IAM)
// role that Amazon Forecast can assume to access the key. You can specify this
// optional object in the CreateDataset and CreatePredictor requests.
EncryptionConfig *types.EncryptionConfig
// Create an Explainability resource for the predictor.
ExplainPredictor *bool
// An array of dimension (field) names that specify how to group the generated
// forecast. For example, if you are generating forecasts for item sales across all
// your stores, and your dataset contains a store_id field, you would specify
// store_id as a dimension to group sales forecasts for each store.
ForecastDimensions []string
// The frequency of predictions in a forecast. Valid intervals are an integer
// followed by Y (Year), M (Month), W (Week), D (Day), H (Hour), and min (Minute).
// For example, "1D" indicates every day and "15min" indicates every 15 minutes.
// You cannot specify a value that would overlap with the next larger frequency.
// That means, for example, you cannot specify a frequency of 60 minutes, because
// that is equivalent to 1 hour. The valid values for each frequency are the
// following:
// - Minute - 1-59
// - Hour - 1-23
// - Day - 1-6
// - Week - 1-4
// - Month - 1-11
// - Year - 1
// Thus, if you want every other week forecasts, specify "2W". Or, if you want
// quarterly forecasts, you specify "3M". The frequency must be greater than or
// equal to the TARGET_TIME_SERIES dataset frequency. When a RELATED_TIME_SERIES
// dataset is provided, the frequency must be equal to the RELATED_TIME_SERIES
// dataset frequency.
ForecastFrequency *string
// The number of time-steps that the model predicts. The forecast horizon is also
// called the prediction length. The maximum forecast horizon is the lesser of 500
// time-steps or 1/4 of the TARGET_TIME_SERIES dataset length. If you are
// retraining an existing AutoPredictor, then the maximum forecast horizon is the
// lesser of 500 time-steps or 1/3 of the TARGET_TIME_SERIES dataset length. If you
// are upgrading to an AutoPredictor or retraining an existing AutoPredictor, you
// cannot update the forecast horizon parameter. You can meet this requirement by
// providing longer time-series in the dataset.
ForecastHorizon *int32
// The forecast types used to train a predictor. You can specify up to five
// forecast types. Forecast types can be quantiles from 0.01 to 0.99, by increments
// of 0.01 or higher. You can also specify the mean forecast with mean .
ForecastTypes []string
// The configuration details for predictor monitoring. Provide a name for the
// monitor resource to enable predictor monitoring. Predictor monitoring allows you
// to see how your predictor's performance changes over time. For more information,
// see Predictor Monitoring (https://docs.aws.amazon.com/forecast/latest/dg/predictor-monitoring.html)
// .
MonitorConfig *types.MonitorConfig
// The accuracy metric used to optimize the predictor.
OptimizationMetric types.OptimizationMetric
// The ARN of the predictor to retrain or upgrade. This parameter is only used
// when retraining or upgrading a predictor. When creating a new predictor, do not
// specify a value for this parameter. When upgrading or retraining a predictor,
// only specify values for the ReferencePredictorArn and PredictorName . The value
// for PredictorName must be a unique predictor name.
ReferencePredictorArn *string
// Optional metadata to help you categorize and organize your predictors. Each tag
// consists of a key and an optional value, both of which you define. Tag keys and
// values are case sensitive. The following restrictions apply to tags:
// - For each resource, each tag key must be unique and each tag key must have
// one value.
// - Maximum number of tags per resource: 50.
// - Maximum key length: 128 Unicode characters in UTF-8.
// - Maximum value length: 256 Unicode characters in UTF-8.
// - Accepted characters: all letters and numbers, spaces representable in
// UTF-8, and + - = . _ : / @. If your tagging schema is used across other services
// and resources, the character restrictions of those services also apply.
// - Key prefixes cannot include any upper or lowercase combination of aws: or
// AWS: . Values can have this prefix. If a tag value has aws as its prefix but
// the key does not, Forecast considers it to be a user tag and will count against
// the limit of 50 tags. Tags with only the key prefix of aws do not count
// against your tags per resource limit. You cannot edit or delete tag keys with
// this prefix.
Tags []types.Tag
// The time boundary Forecast uses to align and aggregate any data that doesn't
// align with your forecast frequency. Provide the unit of time and the time
// boundary as a key value pair. For more information on specifying a time
// boundary, see Specifying a Time Boundary (https://docs.aws.amazon.com/forecast/latest/dg/data-aggregation.html#specifying-time-boundary)
// . If you don't provide a time boundary, Forecast uses a set of Default Time
// Boundaries (https://docs.aws.amazon.com/forecast/latest/dg/data-aggregation.html#default-time-boundaries)
// .
TimeAlignmentBoundary *types.TimeAlignmentBoundary
noSmithyDocumentSerde
}
type CreateAutoPredictorOutput struct {
// The Amazon Resource Name (ARN) of the predictor.
PredictorArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateAutoPredictorMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateAutoPredictor{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateAutoPredictor{}, 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 = addOpCreateAutoPredictorValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateAutoPredictor(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_opCreateAutoPredictor(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "CreateAutoPredictor",
}
}
| 241 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an Amazon Forecast dataset. The information about the dataset that you
// provide helps Forecast understand how to consume the data for model training.
// This includes the following:
// - DataFrequency - How frequently your historical time-series data is
// collected.
// - Domain and DatasetType - Each dataset has an associated dataset domain and a
// type within the domain. Amazon Forecast provides a list of predefined domains
// and types within each domain. For each unique dataset domain and type within the
// domain, Amazon Forecast requires your data to include a minimum set of
// predefined fields.
// - Schema - A schema specifies the fields in the dataset, including the field
// name and data type.
//
// After creating a dataset, you import your training data into it and add the
// dataset to a dataset group. You use the dataset group to create a predictor. For
// more information, see Importing datasets (https://docs.aws.amazon.com/forecast/latest/dg/howitworks-datasets-groups.html)
// . To get a list of all your datasets, use the ListDatasets (https://docs.aws.amazon.com/forecast/latest/dg/API_ListDatasets.html)
// operation. For example Forecast datasets, see the Amazon Forecast Sample GitHub
// repository (https://github.com/aws-samples/amazon-forecast-samples) . The Status
// of a dataset must be ACTIVE before you can import training data. Use the
// DescribeDataset (https://docs.aws.amazon.com/forecast/latest/dg/API_DescribeDataset.html)
// operation to get the status.
func (c *Client) CreateDataset(ctx context.Context, params *CreateDatasetInput, optFns ...func(*Options)) (*CreateDatasetOutput, error) {
if params == nil {
params = &CreateDatasetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateDataset", params, optFns, c.addOperationCreateDatasetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateDatasetOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateDatasetInput struct {
// A name for the dataset.
//
// This member is required.
DatasetName *string
// The dataset type. Valid values depend on the chosen Domain .
//
// This member is required.
DatasetType types.DatasetType
// The domain associated with the dataset. When you add a dataset to a dataset
// group, this value and the value specified for the Domain parameter of the
// CreateDatasetGroup (https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDatasetGroup.html)
// operation must match. The Domain and DatasetType that you choose determine the
// fields that must be present in the training data that you import to the dataset.
// For example, if you choose the RETAIL domain and TARGET_TIME_SERIES as the
// DatasetType , Amazon Forecast requires item_id , timestamp , and demand fields
// to be present in your data. For more information, see Importing datasets (https://docs.aws.amazon.com/forecast/latest/dg/howitworks-datasets-groups.html)
// .
//
// This member is required.
Domain types.Domain
// The schema for the dataset. The schema attributes and their order must match
// the fields in your data. The dataset Domain and DatasetType that you choose
// determine the minimum required fields in your training data. For information
// about the required fields for a specific dataset domain and type, see Dataset
// Domains and Dataset Types (https://docs.aws.amazon.com/forecast/latest/dg/howitworks-domains-ds-types.html)
// .
//
// This member is required.
Schema *types.Schema
// The frequency of data collection. This parameter is required for
// RELATED_TIME_SERIES datasets. Valid intervals are an integer followed by Y
// (Year), M (Month), W (Week), D (Day), H (Hour), and min (Minute). For example,
// "1D" indicates every day and "15min" indicates every 15 minutes. You cannot
// specify a value that would overlap with the next larger frequency. That means,
// for example, you cannot specify a frequency of 60 minutes, because that is
// equivalent to 1 hour. The valid values for each frequency are the following:
// - Minute - 1-59
// - Hour - 1-23
// - Day - 1-6
// - Week - 1-4
// - Month - 1-11
// - Year - 1
// Thus, if you want every other week forecasts, specify "2W". Or, if you want
// quarterly forecasts, you specify "3M".
DataFrequency *string
// An Key Management Service (KMS) key and the Identity and Access Management
// (IAM) role that Amazon Forecast can assume to access the key.
EncryptionConfig *types.EncryptionConfig
// The optional metadata that you apply to the dataset to help you categorize and
// organize them. Each tag consists of a key and an optional value, both of which
// you define. The following basic restrictions apply to tags:
// - Maximum number of tags per resource - 50.
// - For each resource, each tag key must be unique, and each tag key can have
// only one value.
// - Maximum key length - 128 Unicode characters in UTF-8.
// - Maximum value length - 256 Unicode characters in UTF-8.
// - If your tagging schema is used across multiple services and resources,
// remember that other services may have restrictions on allowed characters.
// Generally allowed characters are: letters, numbers, and spaces representable in
// UTF-8, and the following characters: + - = . _ : / @.
// - Tag keys and values are case sensitive.
// - Do not use aws: , AWS: , or any upper or lowercase combination of such as a
// prefix for keys as it is reserved for Amazon Web Services use. You cannot edit
// or delete tag keys with this prefix. Values can have this prefix. If a tag value
// has aws as its prefix but the key does not, then Forecast considers it to be a
// user tag and will count against the limit of 50 tags. Tags with only the key
// prefix of aws do not count against your tags per resource limit.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateDatasetOutput struct {
// The Amazon Resource Name (ARN) of the dataset.
DatasetArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateDatasetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateDataset{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateDataset{}, 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 = addOpCreateDatasetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateDataset(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_opCreateDataset(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "CreateDataset",
}
}
| 216 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a dataset group, which holds a collection of related datasets. You can
// add datasets to the dataset group when you create the dataset group, or later by
// using the UpdateDatasetGroup (https://docs.aws.amazon.com/forecast/latest/dg/API_UpdateDatasetGroup.html)
// operation. After creating a dataset group and adding datasets, you use the
// dataset group when you create a predictor. For more information, see Dataset
// groups (https://docs.aws.amazon.com/forecast/latest/dg/howitworks-datasets-groups.html)
// . To get a list of all your datasets groups, use the ListDatasetGroups (https://docs.aws.amazon.com/forecast/latest/dg/API_ListDatasetGroups.html)
// operation. The Status of a dataset group must be ACTIVE before you can use the
// dataset group to create a predictor. To get the status, use the
// DescribeDatasetGroup (https://docs.aws.amazon.com/forecast/latest/dg/API_DescribeDatasetGroup.html)
// operation.
func (c *Client) CreateDatasetGroup(ctx context.Context, params *CreateDatasetGroupInput, optFns ...func(*Options)) (*CreateDatasetGroupOutput, error) {
if params == nil {
params = &CreateDatasetGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateDatasetGroup", params, optFns, c.addOperationCreateDatasetGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateDatasetGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateDatasetGroupInput struct {
// A name for the dataset group.
//
// This member is required.
DatasetGroupName *string
// The domain associated with the dataset group. When you add a dataset to a
// dataset group, this value and the value specified for the Domain parameter of
// the CreateDataset (https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDataset.html)
// operation must match. The Domain and DatasetType that you choose determine the
// fields that must be present in training data that you import to a dataset. For
// example, if you choose the RETAIL domain and TARGET_TIME_SERIES as the
// DatasetType , Amazon Forecast requires that item_id , timestamp , and demand
// fields are present in your data. For more information, see Dataset groups (https://docs.aws.amazon.com/forecast/latest/dg/howitworks-datasets-groups.html)
// .
//
// This member is required.
Domain types.Domain
// An array of Amazon Resource Names (ARNs) of the datasets that you want to
// include in the dataset group.
DatasetArns []string
// The optional metadata that you apply to the dataset group to help you
// categorize and organize them. Each tag consists of a key and an optional value,
// both of which you define. The following basic restrictions apply to tags:
// - Maximum number of tags per resource - 50.
// - For each resource, each tag key must be unique, and each tag key can have
// only one value.
// - Maximum key length - 128 Unicode characters in UTF-8.
// - Maximum value length - 256 Unicode characters in UTF-8.
// - If your tagging schema is used across multiple services and resources,
// remember that other services may have restrictions on allowed characters.
// Generally allowed characters are: letters, numbers, and spaces representable in
// UTF-8, and the following characters: + - = . _ : / @.
// - Tag keys and values are case sensitive.
// - Do not use aws: , AWS: , or any upper or lowercase combination of such as a
// prefix for keys as it is reserved for Amazon Web Services use. You cannot edit
// or delete tag keys with this prefix. Values can have this prefix. If a tag value
// has aws as its prefix but the key does not, then Forecast considers it to be a
// user tag and will count against the limit of 50 tags. Tags with only the key
// prefix of aws do not count against your tags per resource limit.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateDatasetGroupOutput struct {
// The Amazon Resource Name (ARN) of the dataset group.
DatasetGroupArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateDatasetGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateDatasetGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateDatasetGroup{}, 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 = addOpCreateDatasetGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateDatasetGroup(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_opCreateDatasetGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "CreateDatasetGroup",
}
}
| 173 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Imports your training data to an Amazon Forecast dataset. You provide the
// location of your training data in an Amazon Simple Storage Service (Amazon S3)
// bucket and the Amazon Resource Name (ARN) of the dataset that you want to import
// the data to. You must specify a DataSource (https://docs.aws.amazon.com/forecast/latest/dg/API_DataSource.html)
// object that includes an Identity and Access Management (IAM) role that Amazon
// Forecast can assume to access the data, as Amazon Forecast makes a copy of your
// data and processes it in an internal Amazon Web Services system. For more
// information, see Set up permissions (https://docs.aws.amazon.com/forecast/latest/dg/aws-forecast-iam-roles.html)
// . The training data must be in CSV or Parquet format. The delimiter must be a
// comma (,). You can specify the path to a specific file, the S3 bucket, or to a
// folder in the S3 bucket. For the latter two cases, Amazon Forecast imports all
// files up to the limit of 10,000 files. Because dataset imports are not
// aggregated, your most recent dataset import is the one that is used when
// training a predictor or generating a forecast. Make sure that your most recent
// dataset import contains all of the data you want to model off of, and not just
// the new data collected since the previous import. To get a list of all your
// dataset import jobs, filtered by specified criteria, use the
// ListDatasetImportJobs (https://docs.aws.amazon.com/forecast/latest/dg/API_ListDatasetImportJobs.html)
// operation.
func (c *Client) CreateDatasetImportJob(ctx context.Context, params *CreateDatasetImportJobInput, optFns ...func(*Options)) (*CreateDatasetImportJobOutput, error) {
if params == nil {
params = &CreateDatasetImportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateDatasetImportJob", params, optFns, c.addOperationCreateDatasetImportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateDatasetImportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateDatasetImportJobInput struct {
// The location of the training data to import and an Identity and Access
// Management (IAM) role that Amazon Forecast can assume to access the data. The
// training data must be stored in an Amazon S3 bucket. If encryption is used,
// DataSource must include an Key Management Service (KMS) key and the IAM role
// must allow Amazon Forecast permission to access the key. The KMS key and IAM
// role must match those specified in the EncryptionConfig parameter of the
// CreateDataset (https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDataset.html)
// operation.
//
// This member is required.
DataSource *types.DataSource
// The Amazon Resource Name (ARN) of the Amazon Forecast dataset that you want to
// import data to.
//
// This member is required.
DatasetArn *string
// The name for the dataset import job. We recommend including the current
// timestamp in the name, for example, 20190721DatasetImport . This can help you
// avoid getting a ResourceAlreadyExistsException exception.
//
// This member is required.
DatasetImportJobName *string
// The format of the imported data, CSV or PARQUET. The default value is CSV.
Format *string
// The format of the geolocation attribute. The geolocation attribute can be
// formatted in one of two ways:
// - LAT_LONG - the latitude and longitude in decimal format (Example:
// 47.61_-122.33).
// - CC_POSTALCODE (US Only) - the country code (US), followed by the 5-digit ZIP
// code (Example: US_98121).
GeolocationFormat *string
// Specifies whether the dataset import job is a FULL or INCREMENTAL import. A FULL
// dataset import replaces all of the existing data with the newly imported data.
// An INCREMENTAL import appends the imported data to the existing data.
ImportMode types.ImportMode
// The optional metadata that you apply to the dataset import job to help you
// categorize and organize them. Each tag consists of a key and an optional value,
// both of which you define. The following basic restrictions apply to tags:
// - Maximum number of tags per resource - 50.
// - For each resource, each tag key must be unique, and each tag key can have
// only one value.
// - Maximum key length - 128 Unicode characters in UTF-8.
// - Maximum value length - 256 Unicode characters in UTF-8.
// - If your tagging schema is used across multiple services and resources,
// remember that other services may have restrictions on allowed characters.
// Generally allowed characters are: letters, numbers, and spaces representable in
// UTF-8, and the following characters: + - = . _ : / @.
// - Tag keys and values are case sensitive.
// - Do not use aws: , AWS: , or any upper or lowercase combination of such as a
// prefix for keys as it is reserved for Amazon Web Services use. You cannot edit
// or delete tag keys with this prefix. Values can have this prefix. If a tag value
// has aws as its prefix but the key does not, then Forecast considers it to be a
// user tag and will count against the limit of 50 tags. Tags with only the key
// prefix of aws do not count against your tags per resource limit.
Tags []types.Tag
// A single time zone for every item in your dataset. This option is ideal for
// datasets with all timestamps within a single time zone, or if all timestamps are
// normalized to a single time zone. Refer to the Joda-Time API (http://joda-time.sourceforge.net/timezones.html)
// for a complete list of valid time zone names.
TimeZone *string
// The format of timestamps in the dataset. The format that you specify depends on
// the DataFrequency specified when the dataset was created. The following formats
// are supported
// - "yyyy-MM-dd" For the following data frequencies: Y, M, W, and D
// - "yyyy-MM-dd HH:mm:ss" For the following data frequencies: H, 30min, 15min,
// and 1min; and optionally, for: Y, M, W, and D
// If the format isn't specified, Amazon Forecast expects the format to be
// "yyyy-MM-dd HH:mm:ss".
TimestampFormat *string
// Automatically derive time zone information from the geolocation attribute. This
// option is ideal for datasets that contain timestamps in multiple time zones and
// those timestamps are expressed in local time.
UseGeolocationForTimeZone bool
noSmithyDocumentSerde
}
type CreateDatasetImportJobOutput struct {
// The Amazon Resource Name (ARN) of the dataset import job.
DatasetImportJobArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateDatasetImportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateDatasetImportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateDatasetImportJob{}, 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 = addOpCreateDatasetImportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateDatasetImportJob(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_opCreateDatasetImportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "CreateDatasetImportJob",
}
}
| 221 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Exports an Explainability resource created by the CreateExplainability
// operation. Exported files are exported to an Amazon Simple Storage Service
// (Amazon S3) bucket. You must specify a DataDestination object that includes an
// Amazon S3 bucket and an Identity and Access Management (IAM) role that Amazon
// Forecast can assume to access the Amazon S3 bucket. For more information, see
// aws-forecast-iam-roles . The Status of the export job must be ACTIVE before you
// can access the export in your Amazon S3 bucket. To get the status, use the
// DescribeExplainabilityExport operation.
func (c *Client) CreateExplainabilityExport(ctx context.Context, params *CreateExplainabilityExportInput, optFns ...func(*Options)) (*CreateExplainabilityExportOutput, error) {
if params == nil {
params = &CreateExplainabilityExportInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateExplainabilityExport", params, optFns, c.addOperationCreateExplainabilityExportMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateExplainabilityExportOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateExplainabilityExportInput struct {
// The destination for an export job. Provide an S3 path, an Identity and Access
// Management (IAM) role that allows Amazon Forecast to access the location, and an
// Key Management Service (KMS) key (optional).
//
// This member is required.
Destination *types.DataDestination
// The Amazon Resource Name (ARN) of the Explainability to export.
//
// This member is required.
ExplainabilityArn *string
// A unique name for the Explainability export.
//
// This member is required.
ExplainabilityExportName *string
// The format of the exported data, CSV or PARQUET.
Format *string
// Optional metadata to help you categorize and organize your resources. Each tag
// consists of a key and an optional value, both of which you define. Tag keys and
// values are case sensitive. The following restrictions apply to tags:
// - For each resource, each tag key must be unique and each tag key must have
// one value.
// - Maximum number of tags per resource: 50.
// - Maximum key length: 128 Unicode characters in UTF-8.
// - Maximum value length: 256 Unicode characters in UTF-8.
// - Accepted characters: all letters and numbers, spaces representable in
// UTF-8, and + - = . _ : / @. If your tagging schema is used across other services
// and resources, the character restrictions of those services also apply.
// - Key prefixes cannot include any upper or lowercase combination of aws: or
// AWS: . Values can have this prefix. If a tag value has aws as its prefix but
// the key does not, Forecast considers it to be a user tag and will count against
// the limit of 50 tags. Tags with only the key prefix of aws do not count
// against your tags per resource limit. You cannot edit or delete tag keys with
// this prefix.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateExplainabilityExportOutput struct {
// The Amazon Resource Name (ARN) of the export.
ExplainabilityExportArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateExplainabilityExportMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateExplainabilityExport{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateExplainabilityExport{}, 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 = addOpCreateExplainabilityExportValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateExplainabilityExport(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_opCreateExplainabilityExport(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "CreateExplainabilityExport",
}
}
| 166 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a forecast for each item in the TARGET_TIME_SERIES dataset that was
// used to train the predictor. This is known as inference. To retrieve the
// forecast for a single item at low latency, use the operation. To export the
// complete forecast into your Amazon Simple Storage Service (Amazon S3) bucket,
// use the CreateForecastExportJob operation. The range of the forecast is
// determined by the ForecastHorizon value, which you specify in the
// CreatePredictor request. When you query a forecast, you can request a specific
// date range within the forecast. To get a list of all your forecasts, use the
// ListForecasts operation. The forecasts generated by Amazon Forecast are in the
// same time zone as the dataset that was used to create the predictor. For more
// information, see howitworks-forecast . The Status of the forecast must be ACTIVE
// before you can query or export the forecast. Use the DescribeForecast operation
// to get the status. By default, a forecast includes predictions for every item (
// item_id ) in the dataset group that was used to train the predictor. However,
// you can use the TimeSeriesSelector object to generate a forecast on a subset of
// time series. Forecast creation is skipped for any time series that you specify
// that are not in the input dataset. The forecast export file will not contain
// these time series or their forecasted values.
func (c *Client) CreateForecast(ctx context.Context, params *CreateForecastInput, optFns ...func(*Options)) (*CreateForecastOutput, error) {
if params == nil {
params = &CreateForecastInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateForecast", params, optFns, c.addOperationCreateForecastMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateForecastOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateForecastInput struct {
// A name for the forecast.
//
// This member is required.
ForecastName *string
// The Amazon Resource Name (ARN) of the predictor to use to generate the forecast.
//
// This member is required.
PredictorArn *string
// The quantiles at which probabilistic forecasts are generated. You can currently
// specify up to 5 quantiles per forecast. Accepted values include 0.01 to 0.99
// (increments of .01 only) and mean . The mean forecast is different from the
// median (0.50) when the distribution is not symmetric (for example, Beta and
// Negative Binomial). The default quantiles are the quantiles you specified during
// predictor creation. If you didn't specify quantiles, the default values are
// ["0.1", "0.5", "0.9"] .
ForecastTypes []string
// The optional metadata that you apply to the forecast to help you categorize and
// organize them. Each tag consists of a key and an optional value, both of which
// you define. The following basic restrictions apply to tags:
// - Maximum number of tags per resource - 50.
// - For each resource, each tag key must be unique, and each tag key can have
// only one value.
// - Maximum key length - 128 Unicode characters in UTF-8.
// - Maximum value length - 256 Unicode characters in UTF-8.
// - If your tagging schema is used across multiple services and resources,
// remember that other services may have restrictions on allowed characters.
// Generally allowed characters are: letters, numbers, and spaces representable in
// UTF-8, and the following characters: + - = . _ : / @.
// - Tag keys and values are case sensitive.
// - Do not use aws: , AWS: , or any upper or lowercase combination of such as a
// prefix for keys as it is reserved for Amazon Web Services use. You cannot edit
// or delete tag keys with this prefix. Values can have this prefix. If a tag value
// has aws as its prefix but the key does not, then Forecast considers it to be a
// user tag and will count against the limit of 50 tags. Tags with only the key
// prefix of aws do not count against your tags per resource limit.
Tags []types.Tag
// Defines the set of time series that are used to create the forecasts in a
// TimeSeriesIdentifiers object. The TimeSeriesIdentifiers object needs the
// following information:
// - DataSource
// - Format
// - Schema
TimeSeriesSelector *types.TimeSeriesSelector
noSmithyDocumentSerde
}
type CreateForecastOutput struct {
// The Amazon Resource Name (ARN) of the forecast.
ForecastArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateForecastMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateForecast{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateForecast{}, 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 = addOpCreateForecastValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateForecast(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_opCreateForecast(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "CreateForecast",
}
}
| 185 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Exports a forecast created by the CreateForecast operation to your Amazon
// Simple Storage Service (Amazon S3) bucket. The forecast file name will match the
// following conventions: __ where the component is in Java SimpleDateFormat
// (yyyy-MM-ddTHH-mm-ssZ). You must specify a DataDestination object that includes
// an Identity and Access Management (IAM) role that Amazon Forecast can assume to
// access the Amazon S3 bucket. For more information, see aws-forecast-iam-roles .
// For more information, see howitworks-forecast . To get a list of all your
// forecast export jobs, use the ListForecastExportJobs operation. The Status of
// the forecast export job must be ACTIVE before you can access the forecast in
// your Amazon S3 bucket. To get the status, use the DescribeForecastExportJob
// operation.
func (c *Client) CreateForecastExportJob(ctx context.Context, params *CreateForecastExportJobInput, optFns ...func(*Options)) (*CreateForecastExportJobOutput, error) {
if params == nil {
params = &CreateForecastExportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateForecastExportJob", params, optFns, c.addOperationCreateForecastExportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateForecastExportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateForecastExportJobInput struct {
// The location where you want to save the forecast and an Identity and Access
// Management (IAM) role that Amazon Forecast can assume to access the location.
// The forecast must be exported to an Amazon S3 bucket. If encryption is used,
// Destination must include an Key Management Service (KMS) key. The IAM role must
// allow Amazon Forecast permission to access the key.
//
// This member is required.
Destination *types.DataDestination
// The Amazon Resource Name (ARN) of the forecast that you want to export.
//
// This member is required.
ForecastArn *string
// The name for the forecast export job.
//
// This member is required.
ForecastExportJobName *string
// The format of the exported data, CSV or PARQUET. The default value is CSV.
Format *string
// The optional metadata that you apply to the forecast export job to help you
// categorize and organize them. Each tag consists of a key and an optional value,
// both of which you define. The following basic restrictions apply to tags:
// - Maximum number of tags per resource - 50.
// - For each resource, each tag key must be unique, and each tag key can have
// only one value.
// - Maximum key length - 128 Unicode characters in UTF-8.
// - Maximum value length - 256 Unicode characters in UTF-8.
// - If your tagging schema is used across multiple services and resources,
// remember that other services may have restrictions on allowed characters.
// Generally allowed characters are: letters, numbers, and spaces representable in
// UTF-8, and the following characters: + - = . _ : / @.
// - Tag keys and values are case sensitive.
// - Do not use aws: , AWS: , or any upper or lowercase combination of such as a
// prefix for keys as it is reserved for Amazon Web Services use. You cannot edit
// or delete tag keys with this prefix. Values can have this prefix. If a tag value
// has aws as its prefix but the key does not, then Forecast considers it to be a
// user tag and will count against the limit of 50 tags. Tags with only the key
// prefix of aws do not count against your tags per resource limit.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateForecastExportJobOutput struct {
// The Amazon Resource Name (ARN) of the export job.
ForecastExportJobArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateForecastExportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateForecastExportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateForecastExportJob{}, 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 = addOpCreateForecastExportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateForecastExportJob(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_opCreateForecastExportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "CreateForecastExportJob",
}
}
| 173 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a predictor monitor resource for an existing auto predictor. Predictor
// monitoring allows you to see how your predictor's performance changes over time.
// For more information, see Predictor Monitoring (https://docs.aws.amazon.com/forecast/latest/dg/predictor-monitoring.html)
// .
func (c *Client) CreateMonitor(ctx context.Context, params *CreateMonitorInput, optFns ...func(*Options)) (*CreateMonitorOutput, error) {
if params == nil {
params = &CreateMonitorInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateMonitor", params, optFns, c.addOperationCreateMonitorMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateMonitorOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateMonitorInput struct {
// The name of the monitor resource.
//
// This member is required.
MonitorName *string
// The Amazon Resource Name (ARN) of the predictor to monitor.
//
// This member is required.
ResourceArn *string
// A list of tags (https://docs.aws.amazon.com/forecast/latest/dg/tagging-forecast-resources.html)
// to apply to the monitor resource.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateMonitorOutput struct {
// The Amazon Resource Name (ARN) of the monitor resource.
MonitorArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateMonitorMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateMonitor{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateMonitor{}, 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 = addOpCreateMonitorValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateMonitor(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_opCreateMonitor(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "CreateMonitor",
}
}
| 137 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// This operation creates a legacy predictor that does not include all the
// predictor functionalities provided by Amazon Forecast. To create a predictor
// that is compatible with all aspects of Forecast, use CreateAutoPredictor .
// Creates an Amazon Forecast predictor. In the request, provide a dataset group
// and either specify an algorithm or let Amazon Forecast choose an algorithm for
// you using AutoML. If you specify an algorithm, you also can override
// algorithm-specific hyperparameters. Amazon Forecast uses the algorithm to train
// a predictor using the latest version of the datasets in the specified dataset
// group. You can then generate a forecast using the CreateForecast operation. To
// see the evaluation metrics, use the GetAccuracyMetrics operation. You can
// specify a featurization configuration to fill and aggregate the data fields in
// the TARGET_TIME_SERIES dataset to improve model training. For more information,
// see FeaturizationConfig . For RELATED_TIME_SERIES datasets, CreatePredictor
// verifies that the DataFrequency specified when the dataset was created matches
// the ForecastFrequency . TARGET_TIME_SERIES datasets don't have this restriction.
// Amazon Forecast also verifies the delimiter and timestamp format. For more
// information, see howitworks-datasets-groups . By default, predictors are trained
// and evaluated at the 0.1 (P10), 0.5 (P50), and 0.9 (P90) quantiles. You can
// choose custom forecast types to train and evaluate your predictor by setting the
// ForecastTypes . AutoML If you want Amazon Forecast to evaluate each algorithm
// and choose the one that minimizes the objective function , set PerformAutoML to
// true . The objective function is defined as the mean of the weighted losses
// over the forecast types. By default, these are the p10, p50, and p90 quantile
// losses. For more information, see EvaluationResult . When AutoML is enabled, the
// following properties are disallowed:
// - AlgorithmArn
// - HPOConfig
// - PerformHPO
// - TrainingParameters
//
// To get a list of all of your predictors, use the ListPredictors operation.
// Before you can use the predictor to create a forecast, the Status of the
// predictor must be ACTIVE , signifying that training has completed. To get the
// status, use the DescribePredictor operation.
func (c *Client) CreatePredictor(ctx context.Context, params *CreatePredictorInput, optFns ...func(*Options)) (*CreatePredictorOutput, error) {
if params == nil {
params = &CreatePredictorInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreatePredictor", params, optFns, c.addOperationCreatePredictorMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreatePredictorOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreatePredictorInput struct {
// The featurization configuration.
//
// This member is required.
FeaturizationConfig *types.FeaturizationConfig
// Specifies the number of time-steps that the model is trained to predict. The
// forecast horizon is also called the prediction length. For example, if you
// configure a dataset for daily data collection (using the DataFrequency
// parameter of the CreateDataset operation) and set the forecast horizon to 10,
// the model returns predictions for 10 days. The maximum forecast horizon is the
// lesser of 500 time-steps or 1/3 of the TARGET_TIME_SERIES dataset length.
//
// This member is required.
ForecastHorizon *int32
// Describes the dataset group that contains the data to use to train the
// predictor.
//
// This member is required.
InputDataConfig *types.InputDataConfig
// A name for the predictor.
//
// This member is required.
PredictorName *string
// The Amazon Resource Name (ARN) of the algorithm to use for model training.
// Required if PerformAutoML is not set to true . Supported algorithms:
// - arn:aws:forecast:::algorithm/ARIMA
// - arn:aws:forecast:::algorithm/CNN-QR
// - arn:aws:forecast:::algorithm/Deep_AR_Plus
// - arn:aws:forecast:::algorithm/ETS
// - arn:aws:forecast:::algorithm/NPTS
// - arn:aws:forecast:::algorithm/Prophet
AlgorithmArn *string
// The LatencyOptimized AutoML override strategy is only available in private
// beta. Contact Amazon Web Services Support or your account manager to learn more
// about access privileges. Used to overide the default AutoML strategy, which is
// to optimize predictor accuracy. To apply an AutoML strategy that minimizes
// training time, use LatencyOptimized . This parameter is only valid for
// predictors trained using AutoML.
AutoMLOverrideStrategy types.AutoMLOverrideStrategy
// An Key Management Service (KMS) key and the Identity and Access Management
// (IAM) role that Amazon Forecast can assume to access the key.
EncryptionConfig *types.EncryptionConfig
// Used to override the default evaluation parameters of the specified algorithm.
// Amazon Forecast evaluates a predictor by splitting a dataset into training data
// and testing data. The evaluation parameters define how to perform the split and
// the number of iterations.
EvaluationParameters *types.EvaluationParameters
// Specifies the forecast types used to train a predictor. You can specify up to
// five forecast types. Forecast types can be quantiles from 0.01 to 0.99, by
// increments of 0.01 or higher. You can also specify the mean forecast with mean .
// The default value is ["0.10", "0.50", "0.9"] .
ForecastTypes []string
// Provides hyperparameter override values for the algorithm. If you don't provide
// this parameter, Amazon Forecast uses default values. The individual algorithms
// specify which hyperparameters support hyperparameter optimization (HPO). For
// more information, see aws-forecast-choosing-recipes . If you included the
// HPOConfig object, you must set PerformHPO to true.
HPOConfig *types.HyperParameterTuningJobConfig
// The accuracy metric used to optimize the predictor.
OptimizationMetric types.OptimizationMetric
// Whether to perform AutoML. When Amazon Forecast performs AutoML, it evaluates
// the algorithms it provides and chooses the best algorithm and configuration for
// your training dataset. The default value is false . In this case, you are
// required to specify an algorithm. Set PerformAutoML to true to have Amazon
// Forecast perform AutoML. This is a good option if you aren't sure which
// algorithm is suitable for your training data. In this case, PerformHPO must be
// false.
PerformAutoML *bool
// Whether to perform hyperparameter optimization (HPO). HPO finds optimal
// hyperparameter values for your training data. The process of performing HPO is
// known as running a hyperparameter tuning job. The default value is false . In
// this case, Amazon Forecast uses default hyperparameter values from the chosen
// algorithm. To override the default values, set PerformHPO to true and,
// optionally, supply the HyperParameterTuningJobConfig object. The tuning job
// specifies a metric to optimize, which hyperparameters participate in tuning, and
// the valid range for each tunable hyperparameter. In this case, you are required
// to specify an algorithm and PerformAutoML must be false. The following
// algorithms support HPO:
// - DeepAR+
// - CNN-QR
PerformHPO *bool
// The optional metadata that you apply to the predictor to help you categorize
// and organize them. Each tag consists of a key and an optional value, both of
// which you define. The following basic restrictions apply to tags:
// - Maximum number of tags per resource - 50.
// - For each resource, each tag key must be unique, and each tag key can have
// only one value.
// - Maximum key length - 128 Unicode characters in UTF-8.
// - Maximum value length - 256 Unicode characters in UTF-8.
// - If your tagging schema is used across multiple services and resources,
// remember that other services may have restrictions on allowed characters.
// Generally allowed characters are: letters, numbers, and spaces representable in
// UTF-8, and the following characters: + - = . _ : / @.
// - Tag keys and values are case sensitive.
// - Do not use aws: , AWS: , or any upper or lowercase combination of such as a
// prefix for keys as it is reserved for Amazon Web Services use. You cannot edit
// or delete tag keys with this prefix. Values can have this prefix. If a tag value
// has aws as its prefix but the key does not, then Forecast considers it to be a
// user tag and will count against the limit of 50 tags. Tags with only the key
// prefix of aws do not count against your tags per resource limit.
Tags []types.Tag
// The hyperparameters to override for model training. The hyperparameters that
// you can override are listed in the individual algorithms. For the list of
// supported algorithms, see aws-forecast-choosing-recipes .
TrainingParameters map[string]string
noSmithyDocumentSerde
}
type CreatePredictorOutput struct {
// The Amazon Resource Name (ARN) of the predictor.
PredictorArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreatePredictorMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreatePredictor{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreatePredictor{}, 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 = addOpCreatePredictorValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreatePredictor(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_opCreatePredictor(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "CreatePredictor",
}
}
| 272 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Exports backtest forecasts and accuracy metrics generated by the
// CreateAutoPredictor or CreatePredictor operations. Two folders containing CSV
// or Parquet files are exported to your specified S3 bucket. The export file names
// will match the following conventions: __.csv The component is in Java
// SimpleDate format (yyyy-MM-ddTHH-mm-ssZ). You must specify a DataDestination
// object that includes an Amazon S3 bucket and an Identity and Access Management
// (IAM) role that Amazon Forecast can assume to access the Amazon S3 bucket. For
// more information, see aws-forecast-iam-roles . The Status of the export job
// must be ACTIVE before you can access the export in your Amazon S3 bucket. To
// get the status, use the DescribePredictorBacktestExportJob operation.
func (c *Client) CreatePredictorBacktestExportJob(ctx context.Context, params *CreatePredictorBacktestExportJobInput, optFns ...func(*Options)) (*CreatePredictorBacktestExportJobOutput, error) {
if params == nil {
params = &CreatePredictorBacktestExportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreatePredictorBacktestExportJob", params, optFns, c.addOperationCreatePredictorBacktestExportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreatePredictorBacktestExportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreatePredictorBacktestExportJobInput struct {
// The destination for an export job. Provide an S3 path, an Identity and Access
// Management (IAM) role that allows Amazon Forecast to access the location, and an
// Key Management Service (KMS) key (optional).
//
// This member is required.
Destination *types.DataDestination
// The Amazon Resource Name (ARN) of the predictor that you want to export.
//
// This member is required.
PredictorArn *string
// The name for the backtest export job.
//
// This member is required.
PredictorBacktestExportJobName *string
// The format of the exported data, CSV or PARQUET. The default value is CSV.
Format *string
// Optional metadata to help you categorize and organize your backtests. Each tag
// consists of a key and an optional value, both of which you define. Tag keys and
// values are case sensitive. The following restrictions apply to tags:
// - For each resource, each tag key must be unique and each tag key must have
// one value.
// - Maximum number of tags per resource: 50.
// - Maximum key length: 128 Unicode characters in UTF-8.
// - Maximum value length: 256 Unicode characters in UTF-8.
// - Accepted characters: all letters and numbers, spaces representable in
// UTF-8, and + - = . _ : / @. If your tagging schema is used across other services
// and resources, the character restrictions of those services also apply.
// - Key prefixes cannot include any upper or lowercase combination of aws: or
// AWS: . Values can have this prefix. If a tag value has aws as its prefix but
// the key does not, Forecast considers it to be a user tag and will count against
// the limit of 50 tags. Tags with only the key prefix of aws do not count
// against your tags per resource limit. You cannot edit or delete tag keys with
// this prefix.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreatePredictorBacktestExportJobOutput struct {
// The Amazon Resource Name (ARN) of the predictor backtest export job that you
// want to export.
PredictorBacktestExportJobArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreatePredictorBacktestExportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreatePredictorBacktestExportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreatePredictorBacktestExportJob{}, 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 = addOpCreatePredictorBacktestExportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreatePredictorBacktestExportJob(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_opCreatePredictorBacktestExportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "CreatePredictorBacktestExportJob",
}
}
| 169 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// What-if analysis is a scenario modeling technique where you make a hypothetical
// change to a time series and compare the forecasts generated by these changes
// against the baseline, unchanged time series. It is important to remember that
// the purpose of a what-if analysis is to understand how a forecast can change
// given different modifications to the baseline time series. For example, imagine
// you are a clothing retailer who is considering an end of season sale to clear
// space for new styles. After creating a baseline forecast, you can use a what-if
// analysis to investigate how different sales tactics might affect your goals. You
// could create a scenario where everything is given a 25% markdown, and another
// where everything is given a fixed dollar markdown. You could create a scenario
// where the sale lasts for one week and another where the sale lasts for one
// month. With a what-if analysis, you can compare many different scenarios against
// each other. Note that a what-if analysis is meant to display what the
// forecasting model has learned and how it will behave in the scenarios that you
// are evaluating. Do not blindly use the results of the what-if analysis to make
// business decisions. For instance, forecasts might not be accurate for novel
// scenarios where there is no reference available to determine whether a forecast
// is good. The TimeSeriesSelector object defines the items that you want in the
// what-if analysis.
func (c *Client) CreateWhatIfAnalysis(ctx context.Context, params *CreateWhatIfAnalysisInput, optFns ...func(*Options)) (*CreateWhatIfAnalysisOutput, error) {
if params == nil {
params = &CreateWhatIfAnalysisInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateWhatIfAnalysis", params, optFns, c.addOperationCreateWhatIfAnalysisMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateWhatIfAnalysisOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateWhatIfAnalysisInput struct {
// The Amazon Resource Name (ARN) of the baseline forecast.
//
// This member is required.
ForecastArn *string
// The name of the what-if analysis. Each name must be unique.
//
// This member is required.
WhatIfAnalysisName *string
// A list of tags (https://docs.aws.amazon.com/forecast/latest/dg/tagging-forecast-resources.html)
// to apply to the what if forecast.
Tags []types.Tag
// Defines the set of time series that are used in the what-if analysis with a
// TimeSeriesIdentifiers object. What-if analyses are performed only for the time
// series in this object. The TimeSeriesIdentifiers object needs the following
// information:
// - DataSource
// - Format
// - Schema
TimeSeriesSelector *types.TimeSeriesSelector
noSmithyDocumentSerde
}
type CreateWhatIfAnalysisOutput struct {
// The Amazon Resource Name (ARN) of the what-if analysis.
WhatIfAnalysisArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateWhatIfAnalysisMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateWhatIfAnalysis{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateWhatIfAnalysis{}, 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 = addOpCreateWhatIfAnalysisValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateWhatIfAnalysis(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_opCreateWhatIfAnalysis(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "CreateWhatIfAnalysis",
}
}
| 161 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// A what-if forecast is a forecast that is created from a modified version of the
// baseline forecast. Each what-if forecast incorporates either a replacement
// dataset or a set of transformations to the original dataset.
func (c *Client) CreateWhatIfForecast(ctx context.Context, params *CreateWhatIfForecastInput, optFns ...func(*Options)) (*CreateWhatIfForecastOutput, error) {
if params == nil {
params = &CreateWhatIfForecastInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateWhatIfForecast", params, optFns, c.addOperationCreateWhatIfForecastMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateWhatIfForecastOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateWhatIfForecastInput struct {
// The Amazon Resource Name (ARN) of the what-if analysis.
//
// This member is required.
WhatIfAnalysisArn *string
// The name of the what-if forecast. Names must be unique within each what-if
// analysis.
//
// This member is required.
WhatIfForecastName *string
// A list of tags (https://docs.aws.amazon.com/forecast/latest/dg/tagging-forecast-resources.html)
// to apply to the what if forecast.
Tags []types.Tag
// The replacement time series dataset, which contains the rows that you want to
// change in the related time series dataset. A replacement time series does not
// need to contain all rows that are in the baseline related time series. Include
// only the rows (measure-dimension combinations) that you want to include in the
// what-if forecast. This dataset is merged with the original time series to create
// a transformed dataset that is used for the what-if analysis. This dataset should
// contain the items to modify (such as item_id or workforce_type), any relevant
// dimensions, the timestamp column, and at least one of the related time series
// columns. This file should not contain duplicate timestamps for the same time
// series. Timestamps and item_ids not included in this dataset are not included in
// the what-if analysis.
TimeSeriesReplacementsDataSource *types.TimeSeriesReplacementsDataSource
// The transformations that are applied to the baseline time series. Each
// transformation contains an action and a set of conditions. An action is applied
// only when all conditions are met. If no conditions are provided, the action is
// applied to all items.
TimeSeriesTransformations []types.TimeSeriesTransformation
noSmithyDocumentSerde
}
type CreateWhatIfForecastOutput struct {
// The Amazon Resource Name (ARN) of the what-if forecast.
WhatIfForecastArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateWhatIfForecastMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateWhatIfForecast{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateWhatIfForecast{}, 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 = addOpCreateWhatIfForecastValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateWhatIfForecast(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_opCreateWhatIfForecast(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "CreateWhatIfForecast",
}
}
| 156 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Exports a forecast created by the CreateWhatIfForecast operation to your Amazon
// Simple Storage Service (Amazon S3) bucket. The forecast file name will match the
// following conventions: ≈__ The component is in Java SimpleDateFormat
// (yyyy-MM-ddTHH-mm-ssZ). You must specify a DataDestination object that includes
// an Identity and Access Management (IAM) role that Amazon Forecast can assume to
// access the Amazon S3 bucket. For more information, see aws-forecast-iam-roles .
// For more information, see howitworks-forecast . To get a list of all your
// what-if forecast export jobs, use the ListWhatIfForecastExports operation. The
// Status of the forecast export job must be ACTIVE before you can access the
// forecast in your Amazon S3 bucket. To get the status, use the
// DescribeWhatIfForecastExport operation.
func (c *Client) CreateWhatIfForecastExport(ctx context.Context, params *CreateWhatIfForecastExportInput, optFns ...func(*Options)) (*CreateWhatIfForecastExportOutput, error) {
if params == nil {
params = &CreateWhatIfForecastExportInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateWhatIfForecastExport", params, optFns, c.addOperationCreateWhatIfForecastExportMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateWhatIfForecastExportOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateWhatIfForecastExportInput struct {
// The location where you want to save the forecast and an Identity and Access
// Management (IAM) role that Amazon Forecast can assume to access the location.
// The forecast must be exported to an Amazon S3 bucket. If encryption is used,
// Destination must include an Key Management Service (KMS) key. The IAM role must
// allow Amazon Forecast permission to access the key.
//
// This member is required.
Destination *types.DataDestination
// The list of what-if forecast Amazon Resource Names (ARNs) to export.
//
// This member is required.
WhatIfForecastArns []string
// The name of the what-if forecast to export.
//
// This member is required.
WhatIfForecastExportName *string
// The format of the exported data, CSV or PARQUET.
Format *string
// A list of tags (https://docs.aws.amazon.com/forecast/latest/dg/tagging-forecast-resources.html)
// to apply to the what if forecast.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateWhatIfForecastExportOutput struct {
// The Amazon Resource Name (ARN) of the what-if forecast.
WhatIfForecastExportArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateWhatIfForecastExportMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateWhatIfForecastExport{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateWhatIfForecastExport{}, 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 = addOpCreateWhatIfForecastExportValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateWhatIfForecastExport(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_opCreateWhatIfForecastExport(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "CreateWhatIfForecastExport",
}
}
| 156 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an Amazon Forecast dataset that was created using the CreateDataset (https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDataset.html)
// operation. You can only delete datasets that have a status of ACTIVE or
// CREATE_FAILED . To get the status use the DescribeDataset (https://docs.aws.amazon.com/forecast/latest/dg/API_DescribeDataset.html)
// operation. Forecast does not automatically update any dataset groups that
// contain the deleted dataset. In order to update the dataset group, use the
// UpdateDatasetGroup (https://docs.aws.amazon.com/forecast/latest/dg/API_UpdateDatasetGroup.html)
// operation, omitting the deleted dataset's ARN.
func (c *Client) DeleteDataset(ctx context.Context, params *DeleteDatasetInput, optFns ...func(*Options)) (*DeleteDatasetOutput, error) {
if params == nil {
params = &DeleteDatasetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteDataset", params, optFns, c.addOperationDeleteDatasetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteDatasetOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteDatasetInput struct {
// The Amazon Resource Name (ARN) of the dataset to delete.
//
// This member is required.
DatasetArn *string
noSmithyDocumentSerde
}
type DeleteDatasetOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteDatasetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteDataset{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteDataset{}, 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 = addOpDeleteDatasetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteDataset(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_opDeleteDataset(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DeleteDataset",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a dataset group created using the CreateDatasetGroup (https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDatasetGroup.html)
// operation. You can only delete dataset groups that have a status of ACTIVE ,
// CREATE_FAILED , or UPDATE_FAILED . To get the status, use the
// DescribeDatasetGroup (https://docs.aws.amazon.com/forecast/latest/dg/API_DescribeDatasetGroup.html)
// operation. This operation deletes only the dataset group, not the datasets in
// the group.
func (c *Client) DeleteDatasetGroup(ctx context.Context, params *DeleteDatasetGroupInput, optFns ...func(*Options)) (*DeleteDatasetGroupOutput, error) {
if params == nil {
params = &DeleteDatasetGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteDatasetGroup", params, optFns, c.addOperationDeleteDatasetGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteDatasetGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteDatasetGroupInput struct {
// The Amazon Resource Name (ARN) of the dataset group to delete.
//
// This member is required.
DatasetGroupArn *string
noSmithyDocumentSerde
}
type DeleteDatasetGroupOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteDatasetGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteDatasetGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteDatasetGroup{}, 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 = addOpDeleteDatasetGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteDatasetGroup(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_opDeleteDatasetGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DeleteDatasetGroup",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a dataset import job created using the CreateDatasetImportJob (https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDatasetImportJob.html)
// operation. You can delete only dataset import jobs that have a status of ACTIVE
// or CREATE_FAILED . To get the status, use the DescribeDatasetImportJob (https://docs.aws.amazon.com/forecast/latest/dg/API_DescribeDatasetImportJob.html)
// operation.
func (c *Client) DeleteDatasetImportJob(ctx context.Context, params *DeleteDatasetImportJobInput, optFns ...func(*Options)) (*DeleteDatasetImportJobOutput, error) {
if params == nil {
params = &DeleteDatasetImportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteDatasetImportJob", params, optFns, c.addOperationDeleteDatasetImportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteDatasetImportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteDatasetImportJobInput struct {
// The Amazon Resource Name (ARN) of the dataset import job to delete.
//
// This member is required.
DatasetImportJobArn *string
noSmithyDocumentSerde
}
type DeleteDatasetImportJobOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteDatasetImportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteDatasetImportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteDatasetImportJob{}, 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 = addOpDeleteDatasetImportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteDatasetImportJob(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_opDeleteDatasetImportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DeleteDatasetImportJob",
}
}
| 123 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an Explainability resource. You can delete only predictor that have a
// status of ACTIVE or CREATE_FAILED . To get the status, use the
// DescribeExplainability operation.
func (c *Client) DeleteExplainability(ctx context.Context, params *DeleteExplainabilityInput, optFns ...func(*Options)) (*DeleteExplainabilityOutput, error) {
if params == nil {
params = &DeleteExplainabilityInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteExplainability", params, optFns, c.addOperationDeleteExplainabilityMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteExplainabilityOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteExplainabilityInput struct {
// The Amazon Resource Name (ARN) of the Explainability resource to delete.
//
// This member is required.
ExplainabilityArn *string
noSmithyDocumentSerde
}
type DeleteExplainabilityOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteExplainabilityMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteExplainability{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteExplainability{}, 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 = addOpDeleteExplainabilityValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteExplainability(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_opDeleteExplainability(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DeleteExplainability",
}
}
| 122 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an Explainability export.
func (c *Client) DeleteExplainabilityExport(ctx context.Context, params *DeleteExplainabilityExportInput, optFns ...func(*Options)) (*DeleteExplainabilityExportOutput, error) {
if params == nil {
params = &DeleteExplainabilityExportInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteExplainabilityExport", params, optFns, c.addOperationDeleteExplainabilityExportMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteExplainabilityExportOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteExplainabilityExportInput struct {
// The Amazon Resource Name (ARN) of the Explainability export to delete.
//
// This member is required.
ExplainabilityExportArn *string
noSmithyDocumentSerde
}
type DeleteExplainabilityExportOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteExplainabilityExportMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteExplainabilityExport{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteExplainabilityExport{}, 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 = addOpDeleteExplainabilityExportValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteExplainabilityExport(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_opDeleteExplainabilityExport(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DeleteExplainabilityExport",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a forecast created using the CreateForecast operation. You can delete
// only forecasts that have a status of ACTIVE or CREATE_FAILED . To get the
// status, use the DescribeForecast operation. You can't delete a forecast while
// it is being exported. After a forecast is deleted, you can no longer query the
// forecast.
func (c *Client) DeleteForecast(ctx context.Context, params *DeleteForecastInput, optFns ...func(*Options)) (*DeleteForecastOutput, error) {
if params == nil {
params = &DeleteForecastInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteForecast", params, optFns, c.addOperationDeleteForecastMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteForecastOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteForecastInput struct {
// The Amazon Resource Name (ARN) of the forecast to delete.
//
// This member is required.
ForecastArn *string
noSmithyDocumentSerde
}
type DeleteForecastOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteForecastMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteForecast{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteForecast{}, 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 = addOpDeleteForecastValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteForecast(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_opDeleteForecast(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DeleteForecast",
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a forecast export job created using the CreateForecastExportJob
// operation. You can delete only export jobs that have a status of ACTIVE or
// CREATE_FAILED . To get the status, use the DescribeForecastExportJob operation.
func (c *Client) DeleteForecastExportJob(ctx context.Context, params *DeleteForecastExportJobInput, optFns ...func(*Options)) (*DeleteForecastExportJobOutput, error) {
if params == nil {
params = &DeleteForecastExportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteForecastExportJob", params, optFns, c.addOperationDeleteForecastExportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteForecastExportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteForecastExportJobInput struct {
// The Amazon Resource Name (ARN) of the forecast export job to delete.
//
// This member is required.
ForecastExportJobArn *string
noSmithyDocumentSerde
}
type DeleteForecastExportJobOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteForecastExportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteForecastExportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteForecastExportJob{}, 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 = addOpDeleteForecastExportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteForecastExportJob(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_opDeleteForecastExportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DeleteForecastExportJob",
}
}
| 122 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a monitor resource. You can only delete a monitor resource with a
// status of ACTIVE , ACTIVE_STOPPED , CREATE_FAILED , or CREATE_STOPPED .
func (c *Client) DeleteMonitor(ctx context.Context, params *DeleteMonitorInput, optFns ...func(*Options)) (*DeleteMonitorOutput, error) {
if params == nil {
params = &DeleteMonitorInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteMonitor", params, optFns, c.addOperationDeleteMonitorMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteMonitorOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteMonitorInput struct {
// The Amazon Resource Name (ARN) of the monitor resource to delete.
//
// This member is required.
MonitorArn *string
noSmithyDocumentSerde
}
type DeleteMonitorOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteMonitorMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteMonitor{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteMonitor{}, 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 = addOpDeleteMonitorValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteMonitor(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_opDeleteMonitor(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DeleteMonitor",
}
}
| 121 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a predictor created using the DescribePredictor or CreatePredictor
// operations. You can delete only predictor that have a status of ACTIVE or
// CREATE_FAILED . To get the status, use the DescribePredictor operation.
func (c *Client) DeletePredictor(ctx context.Context, params *DeletePredictorInput, optFns ...func(*Options)) (*DeletePredictorOutput, error) {
if params == nil {
params = &DeletePredictorInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeletePredictor", params, optFns, c.addOperationDeletePredictorMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeletePredictorOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeletePredictorInput struct {
// The Amazon Resource Name (ARN) of the predictor to delete.
//
// This member is required.
PredictorArn *string
noSmithyDocumentSerde
}
type DeletePredictorOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeletePredictorMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeletePredictor{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeletePredictor{}, 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 = addOpDeletePredictorValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeletePredictor(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_opDeletePredictor(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DeletePredictor",
}
}
| 122 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a predictor backtest export job.
func (c *Client) DeletePredictorBacktestExportJob(ctx context.Context, params *DeletePredictorBacktestExportJobInput, optFns ...func(*Options)) (*DeletePredictorBacktestExportJobOutput, error) {
if params == nil {
params = &DeletePredictorBacktestExportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeletePredictorBacktestExportJob", params, optFns, c.addOperationDeletePredictorBacktestExportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeletePredictorBacktestExportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeletePredictorBacktestExportJobInput struct {
// The Amazon Resource Name (ARN) of the predictor backtest export job to delete.
//
// This member is required.
PredictorBacktestExportJobArn *string
noSmithyDocumentSerde
}
type DeletePredictorBacktestExportJobOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeletePredictorBacktestExportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeletePredictorBacktestExportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeletePredictorBacktestExportJob{}, 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 = addOpDeletePredictorBacktestExportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeletePredictorBacktestExportJob(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_opDeletePredictorBacktestExportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DeletePredictorBacktestExportJob",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an entire resource tree. This operation will delete the parent resource
// and its child resources. Child resources are resources that were created from
// another resource. For example, when a forecast is generated from a predictor,
// the forecast is the child resource and the predictor is the parent resource.
// Amazon Forecast resources possess the following parent-child resource
// hierarchies:
// - Dataset: dataset import jobs
// - Dataset Group: predictors, predictor backtest export jobs, forecasts,
// forecast export jobs
// - Predictor: predictor backtest export jobs, forecasts, forecast export jobs
// - Forecast: forecast export jobs
//
// DeleteResourceTree will only delete Amazon Forecast resources, and will not
// delete datasets or exported files stored in Amazon S3.
func (c *Client) DeleteResourceTree(ctx context.Context, params *DeleteResourceTreeInput, optFns ...func(*Options)) (*DeleteResourceTreeOutput, error) {
if params == nil {
params = &DeleteResourceTreeInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteResourceTree", params, optFns, c.addOperationDeleteResourceTreeMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteResourceTreeOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteResourceTreeInput struct {
// The Amazon Resource Name (ARN) of the parent resource to delete. All child
// resources of the parent resource will also be deleted.
//
// This member is required.
ResourceArn *string
noSmithyDocumentSerde
}
type DeleteResourceTreeOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteResourceTreeMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteResourceTree{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteResourceTree{}, 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 = addOpDeleteResourceTreeValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteResourceTree(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_opDeleteResourceTree(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DeleteResourceTree",
}
}
| 134 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a what-if analysis created using the CreateWhatIfAnalysis operation.
// You can delete only what-if analyses that have a status of ACTIVE or
// CREATE_FAILED . To get the status, use the DescribeWhatIfAnalysis operation.
// You can't delete a what-if analysis while any of its forecasts are being
// exported.
func (c *Client) DeleteWhatIfAnalysis(ctx context.Context, params *DeleteWhatIfAnalysisInput, optFns ...func(*Options)) (*DeleteWhatIfAnalysisOutput, error) {
if params == nil {
params = &DeleteWhatIfAnalysisInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteWhatIfAnalysis", params, optFns, c.addOperationDeleteWhatIfAnalysisMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteWhatIfAnalysisOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteWhatIfAnalysisInput struct {
// The Amazon Resource Name (ARN) of the what-if analysis that you want to delete.
//
// This member is required.
WhatIfAnalysisArn *string
noSmithyDocumentSerde
}
type DeleteWhatIfAnalysisOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteWhatIfAnalysisMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteWhatIfAnalysis{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteWhatIfAnalysis{}, 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 = addOpDeleteWhatIfAnalysisValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteWhatIfAnalysis(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_opDeleteWhatIfAnalysis(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DeleteWhatIfAnalysis",
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a what-if forecast created using the CreateWhatIfForecast operation.
// You can delete only what-if forecasts that have a status of ACTIVE or
// CREATE_FAILED . To get the status, use the DescribeWhatIfForecast operation.
// You can't delete a what-if forecast while it is being exported. After a what-if
// forecast is deleted, you can no longer query the what-if analysis.
func (c *Client) DeleteWhatIfForecast(ctx context.Context, params *DeleteWhatIfForecastInput, optFns ...func(*Options)) (*DeleteWhatIfForecastOutput, error) {
if params == nil {
params = &DeleteWhatIfForecastInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteWhatIfForecast", params, optFns, c.addOperationDeleteWhatIfForecastMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteWhatIfForecastOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteWhatIfForecastInput struct {
// The Amazon Resource Name (ARN) of the what-if forecast that you want to delete.
//
// This member is required.
WhatIfForecastArn *string
noSmithyDocumentSerde
}
type DeleteWhatIfForecastOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteWhatIfForecastMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteWhatIfForecast{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteWhatIfForecast{}, 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 = addOpDeleteWhatIfForecastValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteWhatIfForecast(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_opDeleteWhatIfForecast(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DeleteWhatIfForecast",
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a what-if forecast export created using the CreateWhatIfForecastExport
// operation. You can delete only what-if forecast exports that have a status of
// ACTIVE or CREATE_FAILED . To get the status, use the
// DescribeWhatIfForecastExport operation.
func (c *Client) DeleteWhatIfForecastExport(ctx context.Context, params *DeleteWhatIfForecastExportInput, optFns ...func(*Options)) (*DeleteWhatIfForecastExportOutput, error) {
if params == nil {
params = &DeleteWhatIfForecastExportInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteWhatIfForecastExport", params, optFns, c.addOperationDeleteWhatIfForecastExportMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteWhatIfForecastExportOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteWhatIfForecastExportInput struct {
// The Amazon Resource Name (ARN) of the what-if forecast export that you want to
// delete.
//
// This member is required.
WhatIfForecastExportArn *string
noSmithyDocumentSerde
}
type DeleteWhatIfForecastExportOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteWhatIfForecastExportMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteWhatIfForecastExport{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteWhatIfForecastExport{}, 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 = addOpDeleteWhatIfForecastExportValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteWhatIfForecastExport(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_opDeleteWhatIfForecastExport(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DeleteWhatIfForecastExport",
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes a predictor created using the CreateAutoPredictor operation.
func (c *Client) DescribeAutoPredictor(ctx context.Context, params *DescribeAutoPredictorInput, optFns ...func(*Options)) (*DescribeAutoPredictorOutput, error) {
if params == nil {
params = &DescribeAutoPredictorInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeAutoPredictor", params, optFns, c.addOperationDescribeAutoPredictorMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeAutoPredictorOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeAutoPredictorInput struct {
// The Amazon Resource Name (ARN) of the predictor.
//
// This member is required.
PredictorArn *string
noSmithyDocumentSerde
}
type DescribeAutoPredictorOutput struct {
// The timestamp of the CreateAutoPredictor request.
CreationTime *time.Time
// The data configuration for your dataset group and any additional datasets.
DataConfig *types.DataConfig
// An array of the ARNs of the dataset import jobs used to import training data
// for the predictor.
DatasetImportJobArns []string
// An Key Management Service (KMS) key and an Identity and Access Management (IAM)
// role that Amazon Forecast can assume to access the key. You can specify this
// optional object in the CreateDataset and CreatePredictor requests.
EncryptionConfig *types.EncryptionConfig
// The estimated time remaining in minutes for the predictor training job to
// complete.
EstimatedTimeRemainingInMinutes *int64
// Provides the status and ARN of the Predictor Explainability.
ExplainabilityInfo *types.ExplainabilityInfo
// An array of dimension (field) names that specify the attributes used to group
// your time series.
ForecastDimensions []string
// The frequency of predictions in a forecast. Valid intervals are Y (Year), M
// (Month), W (Week), D (Day), H (Hour), 30min (30 minutes), 15min (15 minutes),
// 10min (10 minutes), 5min (5 minutes), and 1min (1 minute). For example, "Y"
// indicates every year and "5min" indicates every five minutes.
ForecastFrequency *string
// The number of time-steps that the model predicts. The forecast horizon is also
// called the prediction length.
ForecastHorizon *int32
// The forecast types used during predictor training. Default value is
// ["0.1","0.5","0.9"].
ForecastTypes []string
// The last time the resource was modified. The timestamp depends on the status of
// the job:
// - CREATE_PENDING - The CreationTime .
// - CREATE_IN_PROGRESS - The current timestamp.
// - CREATE_STOPPING - The current timestamp.
// - CREATE_STOPPED - When the job stopped.
// - ACTIVE or CREATE_FAILED - When the job finished or failed.
LastModificationTime *time.Time
// In the event of an error, a message detailing the cause of the error.
Message *string
// A object with the Amazon Resource Name (ARN) and status of the monitor resource.
MonitorInfo *types.MonitorInfo
// The accuracy metric used to optimize the predictor.
OptimizationMetric types.OptimizationMetric
// The Amazon Resource Name (ARN) of the predictor
PredictorArn *string
// The name of the predictor.
PredictorName *string
// The ARN and state of the reference predictor. This parameter is only valid for
// retrained or upgraded predictors.
ReferencePredictorSummary *types.ReferencePredictorSummary
// The status of the predictor. States include:
// - ACTIVE
// - CREATE_PENDING , CREATE_IN_PROGRESS , CREATE_FAILED
// - CREATE_STOPPING , CREATE_STOPPED
// - DELETE_PENDING , DELETE_IN_PROGRESS , DELETE_FAILED
Status *string
// The time boundary Forecast uses when aggregating data.
TimeAlignmentBoundary *types.TimeAlignmentBoundary
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeAutoPredictorMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeAutoPredictor{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeAutoPredictor{}, 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 = addOpDescribeAutoPredictorValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeAutoPredictor(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_opDescribeAutoPredictor(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DescribeAutoPredictor",
}
}
| 201 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes an Amazon Forecast dataset created using the CreateDataset (https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDataset.html)
// operation. In addition to listing the parameters specified in the CreateDataset
// request, this operation includes the following dataset properties:
// - CreationTime
// - LastModificationTime
// - Status
func (c *Client) DescribeDataset(ctx context.Context, params *DescribeDatasetInput, optFns ...func(*Options)) (*DescribeDatasetOutput, error) {
if params == nil {
params = &DescribeDatasetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDataset", params, optFns, c.addOperationDescribeDatasetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDatasetOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDatasetInput struct {
// The Amazon Resource Name (ARN) of the dataset.
//
// This member is required.
DatasetArn *string
noSmithyDocumentSerde
}
type DescribeDatasetOutput struct {
// When the dataset was created.
CreationTime *time.Time
// The frequency of data collection. Valid intervals are Y (Year), M (Month), W
// (Week), D (Day), H (Hour), 30min (30 minutes), 15min (15 minutes), 10min (10
// minutes), 5min (5 minutes), and 1min (1 minute). For example, "M" indicates
// every month and "30min" indicates every 30 minutes.
DataFrequency *string
// The Amazon Resource Name (ARN) of the dataset.
DatasetArn *string
// The name of the dataset.
DatasetName *string
// The dataset type.
DatasetType types.DatasetType
// The domain associated with the dataset.
Domain types.Domain
// The Key Management Service (KMS) key and the Identity and Access Management
// (IAM) role that Amazon Forecast can assume to access the key.
EncryptionConfig *types.EncryptionConfig
// When you create a dataset, LastModificationTime is the same as CreationTime .
// While data is being imported to the dataset, LastModificationTime is the
// current time of the DescribeDataset call. After a CreateDatasetImportJob (https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDatasetImportJob.html)
// operation has finished, LastModificationTime is when the import job completed
// or failed.
LastModificationTime *time.Time
// An array of SchemaAttribute objects that specify the dataset fields. Each
// SchemaAttribute specifies the name and data type of a field.
Schema *types.Schema
// The status of the dataset. States include:
// - ACTIVE
// - CREATE_PENDING , CREATE_IN_PROGRESS , CREATE_FAILED
// - DELETE_PENDING , DELETE_IN_PROGRESS , DELETE_FAILED
// - UPDATE_PENDING , UPDATE_IN_PROGRESS , UPDATE_FAILED
// The UPDATE states apply while data is imported to the dataset from a call to
// the CreateDatasetImportJob (https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDatasetImportJob.html)
// operation and reflect the status of the dataset import job. For example, when
// the import job status is CREATE_IN_PROGRESS , the status of the dataset is
// UPDATE_IN_PROGRESS . The Status of the dataset must be ACTIVE before you can
// import training data.
Status *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDatasetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeDataset{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeDataset{}, 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 = addOpDescribeDatasetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDataset(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_opDescribeDataset(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DescribeDataset",
}
}
| 177 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes a dataset group created using the CreateDatasetGroup (https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDatasetGroup.html)
// operation. In addition to listing the parameters provided in the
// CreateDatasetGroup request, this operation includes the following properties:
// - DatasetArns - The datasets belonging to the group.
// - CreationTime
// - LastModificationTime
// - Status
func (c *Client) DescribeDatasetGroup(ctx context.Context, params *DescribeDatasetGroupInput, optFns ...func(*Options)) (*DescribeDatasetGroupOutput, error) {
if params == nil {
params = &DescribeDatasetGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDatasetGroup", params, optFns, c.addOperationDescribeDatasetGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDatasetGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDatasetGroupInput struct {
// The Amazon Resource Name (ARN) of the dataset group.
//
// This member is required.
DatasetGroupArn *string
noSmithyDocumentSerde
}
type DescribeDatasetGroupOutput struct {
// When the dataset group was created.
CreationTime *time.Time
// An array of Amazon Resource Names (ARNs) of the datasets contained in the
// dataset group.
DatasetArns []string
// The ARN of the dataset group.
DatasetGroupArn *string
// The name of the dataset group.
DatasetGroupName *string
// The domain associated with the dataset group.
Domain types.Domain
// When the dataset group was created or last updated from a call to the
// UpdateDatasetGroup (https://docs.aws.amazon.com/forecast/latest/dg/API_UpdateDatasetGroup.html)
// operation. While the dataset group is being updated, LastModificationTime is
// the current time of the DescribeDatasetGroup call.
LastModificationTime *time.Time
// The status of the dataset group. States include:
// - ACTIVE
// - CREATE_PENDING , CREATE_IN_PROGRESS , CREATE_FAILED
// - DELETE_PENDING , DELETE_IN_PROGRESS , DELETE_FAILED
// - UPDATE_PENDING , UPDATE_IN_PROGRESS , UPDATE_FAILED
// The UPDATE states apply when you call the UpdateDatasetGroup (https://docs.aws.amazon.com/forecast/latest/dg/API_UpdateDatasetGroup.html)
// operation. The Status of the dataset group must be ACTIVE before you can use
// the dataset group to create a predictor.
Status *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDatasetGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeDatasetGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeDatasetGroup{}, 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 = addOpDescribeDatasetGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDatasetGroup(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_opDescribeDatasetGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DescribeDatasetGroup",
}
}
| 161 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes a dataset import job created using the CreateDatasetImportJob (https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDatasetImportJob.html)
// operation. In addition to listing the parameters provided in the
// CreateDatasetImportJob request, this operation includes the following
// properties:
// - CreationTime
// - LastModificationTime
// - DataSize
// - FieldStatistics
// - Status
// - Message - If an error occurred, information about the error.
func (c *Client) DescribeDatasetImportJob(ctx context.Context, params *DescribeDatasetImportJobInput, optFns ...func(*Options)) (*DescribeDatasetImportJobOutput, error) {
if params == nil {
params = &DescribeDatasetImportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDatasetImportJob", params, optFns, c.addOperationDescribeDatasetImportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDatasetImportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDatasetImportJobInput struct {
// The Amazon Resource Name (ARN) of the dataset import job.
//
// This member is required.
DatasetImportJobArn *string
noSmithyDocumentSerde
}
type DescribeDatasetImportJobOutput struct {
// When the dataset import job was created.
CreationTime *time.Time
// The size of the dataset in gigabytes (GB) after the import job has finished.
DataSize *float64
// The location of the training data to import and an Identity and Access
// Management (IAM) role that Amazon Forecast can assume to access the data. If
// encryption is used, DataSource includes an Key Management Service (KMS) key.
DataSource *types.DataSource
// The Amazon Resource Name (ARN) of the dataset that the training data was
// imported to.
DatasetArn *string
// The ARN of the dataset import job.
DatasetImportJobArn *string
// The name of the dataset import job.
DatasetImportJobName *string
// The estimated time remaining in minutes for the dataset import job to complete.
EstimatedTimeRemainingInMinutes *int64
// Statistical information about each field in the input data.
FieldStatistics map[string]types.Statistics
// The format of the imported data, CSV or PARQUET.
Format *string
// The format of the geolocation attribute. Valid Values: "LAT_LONG" and
// "CC_POSTALCODE" .
GeolocationFormat *string
// The import mode of the dataset import job, FULL or INCREMENTAL.
ImportMode types.ImportMode
// The last time the resource was modified. The timestamp depends on the status of
// the job:
// - CREATE_PENDING - The CreationTime .
// - CREATE_IN_PROGRESS - The current timestamp.
// - CREATE_STOPPING - The current timestamp.
// - CREATE_STOPPED - When the job stopped.
// - ACTIVE or CREATE_FAILED - When the job finished or failed.
LastModificationTime *time.Time
// If an error occurred, an informational message about the error.
Message *string
// The status of the dataset import job. States include:
// - ACTIVE
// - CREATE_PENDING , CREATE_IN_PROGRESS , CREATE_FAILED
// - DELETE_PENDING , DELETE_IN_PROGRESS , DELETE_FAILED
// - CREATE_STOPPING , CREATE_STOPPED
Status *string
// The single time zone applied to every item in the dataset
TimeZone *string
// The format of timestamps in the dataset. The format that you specify depends on
// the DataFrequency specified when the dataset was created. The following formats
// are supported
// - "yyyy-MM-dd" For the following data frequencies: Y, M, W, and D
// - "yyyy-MM-dd HH:mm:ss" For the following data frequencies: H, 30min, 15min,
// and 1min; and optionally, for: Y, M, W, and D
TimestampFormat *string
// Whether TimeZone is automatically derived from the geolocation attribute.
UseGeolocationForTimeZone bool
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDatasetImportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeDatasetImportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeDatasetImportJob{}, 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 = addOpDescribeDatasetImportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDatasetImportJob(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_opDescribeDatasetImportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DescribeDatasetImportJob",
}
}
| 202 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes an Explainability resource created using the CreateExplainability
// operation.
func (c *Client) DescribeExplainability(ctx context.Context, params *DescribeExplainabilityInput, optFns ...func(*Options)) (*DescribeExplainabilityOutput, error) {
if params == nil {
params = &DescribeExplainabilityInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeExplainability", params, optFns, c.addOperationDescribeExplainabilityMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeExplainabilityOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeExplainabilityInput struct {
// The Amazon Resource Name (ARN) of the Explaianability to describe.
//
// This member is required.
ExplainabilityArn *string
noSmithyDocumentSerde
}
type DescribeExplainabilityOutput struct {
// When the Explainability resource was created.
CreationTime *time.Time
// The source of your data, an Identity and Access Management (IAM) role that
// allows Amazon Forecast to access the data and, optionally, an Key Management
// Service (KMS) key.
DataSource *types.DataSource
// Whether the visualization was enabled for the Explainability resource.
EnableVisualization *bool
// If TimePointGranularity is set to SPECIFIC , the last time point in the
// Explainability.
EndDateTime *string
// The estimated time remaining in minutes for the CreateExplainability job to
// complete.
EstimatedTimeRemainingInMinutes *int64
// The Amazon Resource Name (ARN) of the Explainability.
ExplainabilityArn *string
// The configuration settings that define the granularity of time series and time
// points for the Explainability.
ExplainabilityConfig *types.ExplainabilityConfig
// The name of the Explainability.
ExplainabilityName *string
// The last time the resource was modified. The timestamp depends on the status of
// the job:
// - CREATE_PENDING - The CreationTime .
// - CREATE_IN_PROGRESS - The current timestamp.
// - CREATE_STOPPING - The current timestamp.
// - CREATE_STOPPED - When the job stopped.
// - ACTIVE or CREATE_FAILED - When the job finished or failed.
LastModificationTime *time.Time
// If an error occurred, a message about the error.
Message *string
// The Amazon Resource Name (ARN) of the Predictor or Forecast used to create the
// Explainability resource.
ResourceArn *string
// Defines the fields of a dataset.
Schema *types.Schema
// If TimePointGranularity is set to SPECIFIC , the first time point in the
// Explainability.
StartDateTime *string
// The status of the Explainability resource. States include:
// - ACTIVE
// - CREATE_PENDING , CREATE_IN_PROGRESS , CREATE_FAILED
// - CREATE_STOPPING , CREATE_STOPPED
// - DELETE_PENDING , DELETE_IN_PROGRESS , DELETE_FAILED
Status *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeExplainabilityMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeExplainability{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeExplainability{}, 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 = addOpDescribeExplainabilityValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeExplainability(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_opDescribeExplainability(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DescribeExplainability",
}
}
| 183 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes an Explainability export created using the CreateExplainabilityExport
// operation.
func (c *Client) DescribeExplainabilityExport(ctx context.Context, params *DescribeExplainabilityExportInput, optFns ...func(*Options)) (*DescribeExplainabilityExportOutput, error) {
if params == nil {
params = &DescribeExplainabilityExportInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeExplainabilityExport", params, optFns, c.addOperationDescribeExplainabilityExportMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeExplainabilityExportOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeExplainabilityExportInput struct {
// The Amazon Resource Name (ARN) of the Explainability export.
//
// This member is required.
ExplainabilityExportArn *string
noSmithyDocumentSerde
}
type DescribeExplainabilityExportOutput struct {
// When the Explainability export was created.
CreationTime *time.Time
// The destination for an export job. Provide an S3 path, an Identity and Access
// Management (IAM) role that allows Amazon Forecast to access the location, and an
// Key Management Service (KMS) key (optional).
Destination *types.DataDestination
// The Amazon Resource Name (ARN) of the Explainability export.
ExplainabilityArn *string
// The Amazon Resource Name (ARN) of the Explainability export.
ExplainabilityExportArn *string
// The name of the Explainability export.
ExplainabilityExportName *string
// The format of the exported data, CSV or PARQUET.
Format *string
// The last time the resource was modified. The timestamp depends on the status of
// the job:
// - CREATE_PENDING - The CreationTime .
// - CREATE_IN_PROGRESS - The current timestamp.
// - CREATE_STOPPING - The current timestamp.
// - CREATE_STOPPED - When the job stopped.
// - ACTIVE or CREATE_FAILED - When the job finished or failed.
LastModificationTime *time.Time
// Information about any errors that occurred during the export.
Message *string
// The status of the Explainability export. States include:
// - ACTIVE
// - CREATE_PENDING , CREATE_IN_PROGRESS , CREATE_FAILED
// - CREATE_STOPPING , CREATE_STOPPED
// - DELETE_PENDING , DELETE_IN_PROGRESS , DELETE_FAILED
Status *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeExplainabilityExportMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeExplainabilityExport{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeExplainabilityExport{}, 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 = addOpDescribeExplainabilityExportValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeExplainabilityExport(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_opDescribeExplainabilityExport(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DescribeExplainabilityExport",
}
}
| 163 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes a forecast created using the CreateForecast operation. In addition to
// listing the properties provided in the CreateForecast request, this operation
// lists the following properties:
// - DatasetGroupArn - The dataset group that provided the training data.
// - CreationTime
// - LastModificationTime
// - Status
// - Message - If an error occurred, information about the error.
func (c *Client) DescribeForecast(ctx context.Context, params *DescribeForecastInput, optFns ...func(*Options)) (*DescribeForecastOutput, error) {
if params == nil {
params = &DescribeForecastInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeForecast", params, optFns, c.addOperationDescribeForecastMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeForecastOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeForecastInput struct {
// The Amazon Resource Name (ARN) of the forecast.
//
// This member is required.
ForecastArn *string
noSmithyDocumentSerde
}
type DescribeForecastOutput struct {
// When the forecast creation task was created.
CreationTime *time.Time
// The ARN of the dataset group that provided the data used to train the predictor.
DatasetGroupArn *string
// The estimated time remaining in minutes for the forecast job to complete.
EstimatedTimeRemainingInMinutes *int64
// The forecast ARN as specified in the request.
ForecastArn *string
// The name of the forecast.
ForecastName *string
// The quantiles at which probabilistic forecasts were generated.
ForecastTypes []string
// The last time the resource was modified. The timestamp depends on the status of
// the job:
// - CREATE_PENDING - The CreationTime .
// - CREATE_IN_PROGRESS - The current timestamp.
// - CREATE_STOPPING - The current timestamp.
// - CREATE_STOPPED - When the job stopped.
// - ACTIVE or CREATE_FAILED - When the job finished or failed.
LastModificationTime *time.Time
// If an error occurred, an informational message about the error.
Message *string
// The ARN of the predictor used to generate the forecast.
PredictorArn *string
// The status of the forecast. States include:
// - ACTIVE
// - CREATE_PENDING , CREATE_IN_PROGRESS , CREATE_FAILED
// - CREATE_STOPPING , CREATE_STOPPED
// - DELETE_PENDING , DELETE_IN_PROGRESS , DELETE_FAILED
// The Status of the forecast must be ACTIVE before you can query or export the
// forecast.
Status *string
// The time series to include in the forecast.
TimeSeriesSelector *types.TimeSeriesSelector
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeForecastMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeForecast{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeForecast{}, 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 = addOpDescribeForecastValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeForecast(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_opDescribeForecast(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DescribeForecast",
}
}
| 175 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes a forecast export job created using the CreateForecastExportJob
// operation. In addition to listing the properties provided by the user in the
// CreateForecastExportJob request, this operation lists the following properties:
// - CreationTime
// - LastModificationTime
// - Status
// - Message - If an error occurred, information about the error.
func (c *Client) DescribeForecastExportJob(ctx context.Context, params *DescribeForecastExportJobInput, optFns ...func(*Options)) (*DescribeForecastExportJobOutput, error) {
if params == nil {
params = &DescribeForecastExportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeForecastExportJob", params, optFns, c.addOperationDescribeForecastExportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeForecastExportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeForecastExportJobInput struct {
// The Amazon Resource Name (ARN) of the forecast export job.
//
// This member is required.
ForecastExportJobArn *string
noSmithyDocumentSerde
}
type DescribeForecastExportJobOutput struct {
// When the forecast export job was created.
CreationTime *time.Time
// The path to the Amazon Simple Storage Service (Amazon S3) bucket where the
// forecast is exported.
Destination *types.DataDestination
// The Amazon Resource Name (ARN) of the exported forecast.
ForecastArn *string
// The ARN of the forecast export job.
ForecastExportJobArn *string
// The name of the forecast export job.
ForecastExportJobName *string
// The format of the exported data, CSV or PARQUET.
Format *string
// The last time the resource was modified. The timestamp depends on the status of
// the job:
// - CREATE_PENDING - The CreationTime .
// - CREATE_IN_PROGRESS - The current timestamp.
// - CREATE_STOPPING - The current timestamp.
// - CREATE_STOPPED - When the job stopped.
// - ACTIVE or CREATE_FAILED - When the job finished or failed.
LastModificationTime *time.Time
// If an error occurred, an informational message about the error.
Message *string
// The status of the forecast export job. States include:
// - ACTIVE
// - CREATE_PENDING , CREATE_IN_PROGRESS , CREATE_FAILED
// - CREATE_STOPPING , CREATE_STOPPED
// - DELETE_PENDING , DELETE_IN_PROGRESS , DELETE_FAILED
// The Status of the forecast export job must be ACTIVE before you can access the
// forecast in your S3 bucket.
Status *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeForecastExportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeForecastExportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeForecastExportJob{}, 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 = addOpDescribeForecastExportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeForecastExportJob(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_opDescribeForecastExportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DescribeForecastExportJob",
}
}
| 169 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes a monitor resource. In addition to listing the properties provided in
// the CreateMonitor request, this operation lists the following properties:
// - Baseline
// - CreationTime
// - LastEvaluationTime
// - LastEvaluationState
// - LastModificationTime
// - Message
// - Status
func (c *Client) DescribeMonitor(ctx context.Context, params *DescribeMonitorInput, optFns ...func(*Options)) (*DescribeMonitorOutput, error) {
if params == nil {
params = &DescribeMonitorInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeMonitor", params, optFns, c.addOperationDescribeMonitorMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeMonitorOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeMonitorInput struct {
// The Amazon Resource Name (ARN) of the monitor resource to describe.
//
// This member is required.
MonitorArn *string
noSmithyDocumentSerde
}
type DescribeMonitorOutput struct {
// Metrics you can use as a baseline for comparison purposes. Use these values you
// interpret monitoring results for an auto predictor.
Baseline *types.Baseline
// The timestamp for when the monitor resource was created.
CreationTime *time.Time
// The estimated number of minutes remaining before the monitor resource finishes
// its current evaluation.
EstimatedEvaluationTimeRemainingInMinutes *int64
// The state of the monitor's latest evaluation.
LastEvaluationState *string
// The timestamp of the latest evaluation completed by the monitor.
LastEvaluationTime *time.Time
// The timestamp of the latest modification to the monitor.
LastModificationTime *time.Time
// An error message, if any, for the monitor.
Message *string
// The Amazon Resource Name (ARN) of the monitor resource described.
MonitorArn *string
// The name of the monitor.
MonitorName *string
// The Amazon Resource Name (ARN) of the auto predictor being monitored.
ResourceArn *string
// The status of the monitor resource.
Status *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeMonitorMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeMonitor{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeMonitor{}, 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 = addOpDescribeMonitorValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeMonitor(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_opDescribeMonitor(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DescribeMonitor",
}
}
| 166 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// This operation is only valid for legacy predictors created with
// CreatePredictor. If you are not using a legacy predictor, use
// DescribeAutoPredictor . Describes a predictor created using the CreatePredictor
// operation. In addition to listing the properties provided in the CreatePredictor
// request, this operation lists the following properties:
// - DatasetImportJobArns - The dataset import jobs used to import training data.
// - AutoMLAlgorithmArns - If AutoML is performed, the algorithms that were
// evaluated.
// - CreationTime
// - LastModificationTime
// - Status
// - Message - If an error occurred, information about the error.
func (c *Client) DescribePredictor(ctx context.Context, params *DescribePredictorInput, optFns ...func(*Options)) (*DescribePredictorOutput, error) {
if params == nil {
params = &DescribePredictorInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribePredictor", params, optFns, c.addOperationDescribePredictorMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribePredictorOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribePredictorInput struct {
// The Amazon Resource Name (ARN) of the predictor that you want information about.
//
// This member is required.
PredictorArn *string
noSmithyDocumentSerde
}
type DescribePredictorOutput struct {
// The Amazon Resource Name (ARN) of the algorithm used for model training.
AlgorithmArn *string
// When PerformAutoML is specified, the ARN of the chosen algorithm.
AutoMLAlgorithmArns []string
// The LatencyOptimized AutoML override strategy is only available in private
// beta. Contact Amazon Web Services Support or your account manager to learn more
// about access privileges. The AutoML strategy used to train the predictor. Unless
// LatencyOptimized is specified, the AutoML strategy optimizes predictor
// accuracy. This parameter is only valid for predictors trained using AutoML.
AutoMLOverrideStrategy types.AutoMLOverrideStrategy
// When the model training task was created.
CreationTime *time.Time
// An array of the ARNs of the dataset import jobs used to import training data
// for the predictor.
DatasetImportJobArns []string
// An Key Management Service (KMS) key and the Identity and Access Management
// (IAM) role that Amazon Forecast can assume to access the key.
EncryptionConfig *types.EncryptionConfig
// The estimated time remaining in minutes for the predictor training job to
// complete.
EstimatedTimeRemainingInMinutes *int64
// Used to override the default evaluation parameters of the specified algorithm.
// Amazon Forecast evaluates a predictor by splitting a dataset into training data
// and testing data. The evaluation parameters define how to perform the split and
// the number of iterations.
EvaluationParameters *types.EvaluationParameters
// The featurization configuration.
FeaturizationConfig *types.FeaturizationConfig
// The number of time-steps of the forecast. The forecast horizon is also called
// the prediction length.
ForecastHorizon *int32
// The forecast types used during predictor training. Default value is
// ["0.1","0.5","0.9"]
ForecastTypes []string
// The hyperparameter override values for the algorithm.
HPOConfig *types.HyperParameterTuningJobConfig
// Describes the dataset group that contains the data to use to train the
// predictor.
InputDataConfig *types.InputDataConfig
// Whether the predictor was created with CreateAutoPredictor .
IsAutoPredictor *bool
// The last time the resource was modified. The timestamp depends on the status of
// the job:
// - CREATE_PENDING - The CreationTime .
// - CREATE_IN_PROGRESS - The current timestamp.
// - CREATE_STOPPING - The current timestamp.
// - CREATE_STOPPED - When the job stopped.
// - ACTIVE or CREATE_FAILED - When the job finished or failed.
LastModificationTime *time.Time
// If an error occurred, an informational message about the error.
Message *string
// The accuracy metric used to optimize the predictor.
OptimizationMetric types.OptimizationMetric
// Whether the predictor is set to perform AutoML.
PerformAutoML *bool
// Whether the predictor is set to perform hyperparameter optimization (HPO).
PerformHPO *bool
// The ARN of the predictor.
PredictorArn *string
// Details on the the status and results of the backtests performed to evaluate
// the accuracy of the predictor. You specify the number of backtests to perform
// when you call the operation.
PredictorExecutionDetails *types.PredictorExecutionDetails
// The name of the predictor.
PredictorName *string
// The status of the predictor. States include:
// - ACTIVE
// - CREATE_PENDING , CREATE_IN_PROGRESS , CREATE_FAILED
// - DELETE_PENDING , DELETE_IN_PROGRESS , DELETE_FAILED
// - CREATE_STOPPING , CREATE_STOPPED
// The Status of the predictor must be ACTIVE before you can use the predictor to
// create a forecast.
Status *string
// The default training parameters or overrides selected during model training.
// When running AutoML or choosing HPO with CNN-QR or DeepAR+, the optimized values
// for the chosen hyperparameters are returned. For more information, see
// aws-forecast-choosing-recipes .
TrainingParameters map[string]string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribePredictorMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribePredictor{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribePredictor{}, 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 = addOpDescribePredictorValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribePredictor(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_opDescribePredictor(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DescribePredictor",
}
}
| 236 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes a predictor backtest export job created using the
// CreatePredictorBacktestExportJob operation. In addition to listing the
// properties provided by the user in the CreatePredictorBacktestExportJob
// request, this operation lists the following properties:
// - CreationTime
// - LastModificationTime
// - Status
// - Message (if an error occurred)
func (c *Client) DescribePredictorBacktestExportJob(ctx context.Context, params *DescribePredictorBacktestExportJobInput, optFns ...func(*Options)) (*DescribePredictorBacktestExportJobOutput, error) {
if params == nil {
params = &DescribePredictorBacktestExportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribePredictorBacktestExportJob", params, optFns, c.addOperationDescribePredictorBacktestExportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribePredictorBacktestExportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribePredictorBacktestExportJobInput struct {
// The Amazon Resource Name (ARN) of the predictor backtest export job.
//
// This member is required.
PredictorBacktestExportJobArn *string
noSmithyDocumentSerde
}
type DescribePredictorBacktestExportJobOutput struct {
// When the predictor backtest export job was created.
CreationTime *time.Time
// The destination for an export job. Provide an S3 path, an Identity and Access
// Management (IAM) role that allows Amazon Forecast to access the location, and an
// Key Management Service (KMS) key (optional).
Destination *types.DataDestination
// The format of the exported data, CSV or PARQUET.
Format *string
// The last time the resource was modified. The timestamp depends on the status of
// the job:
// - CREATE_PENDING - The CreationTime .
// - CREATE_IN_PROGRESS - The current timestamp.
// - CREATE_STOPPING - The current timestamp.
// - CREATE_STOPPED - When the job stopped.
// - ACTIVE or CREATE_FAILED - When the job finished or failed.
LastModificationTime *time.Time
// Information about any errors that may have occurred during the backtest export.
Message *string
// The Amazon Resource Name (ARN) of the predictor.
PredictorArn *string
// The Amazon Resource Name (ARN) of the predictor backtest export job.
PredictorBacktestExportJobArn *string
// The name of the predictor backtest export job.
PredictorBacktestExportJobName *string
// The status of the predictor backtest export job. States include:
// - ACTIVE
// - CREATE_PENDING , CREATE_IN_PROGRESS , CREATE_FAILED
// - CREATE_STOPPING , CREATE_STOPPED
// - DELETE_PENDING , DELETE_IN_PROGRESS , DELETE_FAILED
Status *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribePredictorBacktestExportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribePredictorBacktestExportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribePredictorBacktestExportJob{}, 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 = addOpDescribePredictorBacktestExportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribePredictorBacktestExportJob(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_opDescribePredictorBacktestExportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DescribePredictorBacktestExportJob",
}
}
| 169 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes the what-if analysis created using the CreateWhatIfAnalysis
// operation. In addition to listing the properties provided in the
// CreateWhatIfAnalysis request, this operation lists the following properties:
// - CreationTime
// - LastModificationTime
// - Message - If an error occurred, information about the error.
// - Status
func (c *Client) DescribeWhatIfAnalysis(ctx context.Context, params *DescribeWhatIfAnalysisInput, optFns ...func(*Options)) (*DescribeWhatIfAnalysisOutput, error) {
if params == nil {
params = &DescribeWhatIfAnalysisInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeWhatIfAnalysis", params, optFns, c.addOperationDescribeWhatIfAnalysisMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeWhatIfAnalysisOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeWhatIfAnalysisInput struct {
// The Amazon Resource Name (ARN) of the what-if analysis that you are interested
// in.
//
// This member is required.
WhatIfAnalysisArn *string
noSmithyDocumentSerde
}
type DescribeWhatIfAnalysisOutput struct {
// When the what-if analysis was created.
CreationTime *time.Time
// The approximate time remaining to complete the what-if analysis, in minutes.
EstimatedTimeRemainingInMinutes *int64
// The Amazon Resource Name (ARN) of the what-if forecast.
ForecastArn *string
// The last time the resource was modified. The timestamp depends on the status of
// the job:
// - CREATE_PENDING - The CreationTime .
// - CREATE_IN_PROGRESS - The current timestamp.
// - CREATE_STOPPING - The current timestamp.
// - CREATE_STOPPED - When the job stopped.
// - ACTIVE or CREATE_FAILED - When the job finished or failed.
LastModificationTime *time.Time
// If an error occurred, an informational message about the error.
Message *string
// The status of the what-if analysis. States include:
// - ACTIVE
// - CREATE_PENDING , CREATE_IN_PROGRESS , CREATE_FAILED
// - CREATE_STOPPING , CREATE_STOPPED
// - DELETE_PENDING , DELETE_IN_PROGRESS , DELETE_FAILED
// The Status of the what-if analysis must be ACTIVE before you can access the
// analysis.
Status *string
// Defines the set of time series that are used to create the forecasts in a
// TimeSeriesIdentifiers object. The TimeSeriesIdentifiers object needs the
// following information:
// - DataSource
// - Format
// - Schema
TimeSeriesSelector *types.TimeSeriesSelector
// The Amazon Resource Name (ARN) of the what-if analysis.
WhatIfAnalysisArn *string
// The name of the what-if analysis.
WhatIfAnalysisName *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeWhatIfAnalysisMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeWhatIfAnalysis{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeWhatIfAnalysis{}, 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 = addOpDescribeWhatIfAnalysisValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeWhatIfAnalysis(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_opDescribeWhatIfAnalysis(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DescribeWhatIfAnalysis",
}
}
| 174 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes the what-if forecast created using the CreateWhatIfForecast
// operation. In addition to listing the properties provided in the
// CreateWhatIfForecast request, this operation lists the following properties:
// - CreationTime
// - LastModificationTime
// - Message - If an error occurred, information about the error.
// - Status
func (c *Client) DescribeWhatIfForecast(ctx context.Context, params *DescribeWhatIfForecastInput, optFns ...func(*Options)) (*DescribeWhatIfForecastOutput, error) {
if params == nil {
params = &DescribeWhatIfForecastInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeWhatIfForecast", params, optFns, c.addOperationDescribeWhatIfForecastMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeWhatIfForecastOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeWhatIfForecastInput struct {
// The Amazon Resource Name (ARN) of the what-if forecast that you are interested
// in.
//
// This member is required.
WhatIfForecastArn *string
noSmithyDocumentSerde
}
type DescribeWhatIfForecastOutput struct {
// When the what-if forecast was created.
CreationTime *time.Time
// The approximate time remaining to complete the what-if forecast, in minutes.
EstimatedTimeRemainingInMinutes *int64
// The quantiles at which probabilistic forecasts are generated. You can specify
// up to five quantiles per what-if forecast in the CreateWhatIfForecast
// operation. If you didn't specify quantiles, the default values are ["0.1",
// "0.5", "0.9"] .
ForecastTypes []string
// The last time the resource was modified. The timestamp depends on the status of
// the job:
// - CREATE_PENDING - The CreationTime .
// - CREATE_IN_PROGRESS - The current timestamp.
// - CREATE_STOPPING - The current timestamp.
// - CREATE_STOPPED - When the job stopped.
// - ACTIVE or CREATE_FAILED - When the job finished or failed.
LastModificationTime *time.Time
// If an error occurred, an informational message about the error.
Message *string
// The status of the what-if forecast. States include:
// - ACTIVE
// - CREATE_PENDING , CREATE_IN_PROGRESS , CREATE_FAILED
// - CREATE_STOPPING , CREATE_STOPPED
// - DELETE_PENDING , DELETE_IN_PROGRESS , DELETE_FAILED
// The Status of the what-if forecast must be ACTIVE before you can access the
// forecast.
Status *string
// An array of S3Config , Schema , and Format elements that describe the
// replacement time series.
TimeSeriesReplacementsDataSource *types.TimeSeriesReplacementsDataSource
// An array of Action and TimeSeriesConditions elements that describe what
// transformations were applied to which time series.
TimeSeriesTransformations []types.TimeSeriesTransformation
// The Amazon Resource Name (ARN) of the what-if analysis that contains this
// forecast.
WhatIfAnalysisArn *string
// The Amazon Resource Name (ARN) of the what-if forecast.
WhatIfForecastArn *string
// The name of the what-if forecast.
WhatIfForecastName *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeWhatIfForecastMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeWhatIfForecast{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeWhatIfForecast{}, 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 = addOpDescribeWhatIfForecastValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeWhatIfForecast(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_opDescribeWhatIfForecast(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DescribeWhatIfForecast",
}
}
| 181 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes the what-if forecast export created using the
// CreateWhatIfForecastExport operation. In addition to listing the properties
// provided in the CreateWhatIfForecastExport request, this operation lists the
// following properties:
// - CreationTime
// - LastModificationTime
// - Message - If an error occurred, information about the error.
// - Status
func (c *Client) DescribeWhatIfForecastExport(ctx context.Context, params *DescribeWhatIfForecastExportInput, optFns ...func(*Options)) (*DescribeWhatIfForecastExportOutput, error) {
if params == nil {
params = &DescribeWhatIfForecastExportInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeWhatIfForecastExport", params, optFns, c.addOperationDescribeWhatIfForecastExportMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeWhatIfForecastExportOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeWhatIfForecastExportInput struct {
// The Amazon Resource Name (ARN) of the what-if forecast export that you are
// interested in.
//
// This member is required.
WhatIfForecastExportArn *string
noSmithyDocumentSerde
}
type DescribeWhatIfForecastExportOutput struct {
// When the what-if forecast export was created.
CreationTime *time.Time
// The destination for an export job. Provide an S3 path, an Identity and Access
// Management (IAM) role that allows Amazon Forecast to access the location, and an
// Key Management Service (KMS) key (optional).
Destination *types.DataDestination
// The approximate time remaining to complete the what-if forecast export, in
// minutes.
EstimatedTimeRemainingInMinutes *int64
// The format of the exported data, CSV or PARQUET.
Format *string
// The last time the resource was modified. The timestamp depends on the status of
// the job:
// - CREATE_PENDING - The CreationTime .
// - CREATE_IN_PROGRESS - The current timestamp.
// - CREATE_STOPPING - The current timestamp.
// - CREATE_STOPPED - When the job stopped.
// - ACTIVE or CREATE_FAILED - When the job finished or failed.
LastModificationTime *time.Time
// If an error occurred, an informational message about the error.
Message *string
// The status of the what-if forecast. States include:
// - ACTIVE
// - CREATE_PENDING , CREATE_IN_PROGRESS , CREATE_FAILED
// - CREATE_STOPPING , CREATE_STOPPED
// - DELETE_PENDING , DELETE_IN_PROGRESS , DELETE_FAILED
// The Status of the what-if forecast export must be ACTIVE before you can access
// the forecast export.
Status *string
// An array of Amazon Resource Names (ARNs) that represent all of the what-if
// forecasts exported in this resource.
WhatIfForecastArns []string
// The Amazon Resource Name (ARN) of the what-if forecast export.
WhatIfForecastExportArn *string
// The name of the what-if forecast export.
WhatIfForecastExportName *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeWhatIfForecastExportMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeWhatIfForecastExport{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeWhatIfForecastExport{}, 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 = addOpDescribeWhatIfForecastExportValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeWhatIfForecastExport(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_opDescribeWhatIfForecastExport(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "DescribeWhatIfForecastExport",
}
}
| 177 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Provides metrics on the accuracy of the models that were trained by the
// CreatePredictor operation. Use metrics to see how well the model performed and
// to decide whether to use the predictor to generate a forecast. For more
// information, see Predictor Metrics (https://docs.aws.amazon.com/forecast/latest/dg/metrics.html)
// . This operation generates metrics for each backtest window that was evaluated.
// The number of backtest windows ( NumberOfBacktestWindows ) is specified using
// the EvaluationParameters object, which is optionally included in the
// CreatePredictor request. If NumberOfBacktestWindows isn't specified, the number
// defaults to one. The parameters of the filling method determine which items
// contribute to the metrics. If you want all items to contribute, specify zero .
// If you want only those items that have complete data in the range being
// evaluated to contribute, specify nan . For more information, see
// FeaturizationMethod . Before you can get accuracy metrics, the Status of the
// predictor must be ACTIVE , signifying that training has completed. To get the
// status, use the DescribePredictor operation.
func (c *Client) GetAccuracyMetrics(ctx context.Context, params *GetAccuracyMetricsInput, optFns ...func(*Options)) (*GetAccuracyMetricsOutput, error) {
if params == nil {
params = &GetAccuracyMetricsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "GetAccuracyMetrics", params, optFns, c.addOperationGetAccuracyMetricsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*GetAccuracyMetricsOutput)
out.ResultMetadata = metadata
return out, nil
}
type GetAccuracyMetricsInput struct {
// The Amazon Resource Name (ARN) of the predictor to get metrics for.
//
// This member is required.
PredictorArn *string
noSmithyDocumentSerde
}
type GetAccuracyMetricsOutput struct {
// The LatencyOptimized AutoML override strategy is only available in private
// beta. Contact Amazon Web Services Support or your account manager to learn more
// about access privileges. The AutoML strategy used to train the predictor. Unless
// LatencyOptimized is specified, the AutoML strategy optimizes predictor
// accuracy. This parameter is only valid for predictors trained using AutoML.
AutoMLOverrideStrategy types.AutoMLOverrideStrategy
// Whether the predictor was created with CreateAutoPredictor .
IsAutoPredictor *bool
// The accuracy metric used to optimize the predictor.
OptimizationMetric types.OptimizationMetric
// An array of results from evaluating the predictor.
PredictorEvaluationResults []types.EvaluationResult
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationGetAccuracyMetricsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetAccuracyMetrics{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetAccuracyMetrics{}, 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 = addOpGetAccuracyMetricsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetAccuracyMetrics(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_opGetAccuracyMetrics(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "GetAccuracyMetrics",
}
}
| 152 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of dataset groups created using the CreateDatasetGroup (https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDatasetGroup.html)
// operation. For each dataset group, this operation returns a summary of its
// properties, including its Amazon Resource Name (ARN). You can retrieve the
// complete set of properties by using the dataset group ARN with the
// DescribeDatasetGroup (https://docs.aws.amazon.com/forecast/latest/dg/API_DescribeDatasetGroup.html)
// operation.
func (c *Client) ListDatasetGroups(ctx context.Context, params *ListDatasetGroupsInput, optFns ...func(*Options)) (*ListDatasetGroupsOutput, error) {
if params == nil {
params = &ListDatasetGroupsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDatasetGroups", params, optFns, c.addOperationListDatasetGroupsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDatasetGroupsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDatasetGroupsInput struct {
// The number of items to return in the response.
MaxResults *int32
// If the result of the previous request was truncated, the response includes a
// NextToken . To retrieve the next set of results, use the token in the next
// request. Tokens expire after 24 hours.
NextToken *string
noSmithyDocumentSerde
}
type ListDatasetGroupsOutput struct {
// An array of objects that summarize each dataset group's properties.
DatasetGroups []types.DatasetGroupSummary
// If the response is truncated, Amazon Forecast returns this token. To retrieve
// the next set of results, use the token in the next request.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDatasetGroupsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListDatasetGroups{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListDatasetGroups{}, 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_opListDatasetGroups(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
}
// ListDatasetGroupsAPIClient is a client that implements the ListDatasetGroups
// operation.
type ListDatasetGroupsAPIClient interface {
ListDatasetGroups(context.Context, *ListDatasetGroupsInput, ...func(*Options)) (*ListDatasetGroupsOutput, error)
}
var _ ListDatasetGroupsAPIClient = (*Client)(nil)
// ListDatasetGroupsPaginatorOptions is the paginator options for ListDatasetGroups
type ListDatasetGroupsPaginatorOptions struct {
// The number of items 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
}
// ListDatasetGroupsPaginator is a paginator for ListDatasetGroups
type ListDatasetGroupsPaginator struct {
options ListDatasetGroupsPaginatorOptions
client ListDatasetGroupsAPIClient
params *ListDatasetGroupsInput
nextToken *string
firstPage bool
}
// NewListDatasetGroupsPaginator returns a new ListDatasetGroupsPaginator
func NewListDatasetGroupsPaginator(client ListDatasetGroupsAPIClient, params *ListDatasetGroupsInput, optFns ...func(*ListDatasetGroupsPaginatorOptions)) *ListDatasetGroupsPaginator {
if params == nil {
params = &ListDatasetGroupsInput{}
}
options := ListDatasetGroupsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListDatasetGroupsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListDatasetGroupsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListDatasetGroups page.
func (p *ListDatasetGroupsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDatasetGroupsOutput, 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.ListDatasetGroups(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_opListDatasetGroups(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "ListDatasetGroups",
}
}
| 225 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of dataset import jobs created using the CreateDatasetImportJob (https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDatasetImportJob.html)
// operation. For each import job, this operation returns a summary of its
// properties, including its Amazon Resource Name (ARN). You can retrieve the
// complete set of properties by using the ARN with the DescribeDatasetImportJob (https://docs.aws.amazon.com/forecast/latest/dg/API_DescribeDatasetImportJob.html)
// operation. You can filter the list by providing an array of Filter (https://docs.aws.amazon.com/forecast/latest/dg/API_Filter.html)
// objects.
func (c *Client) ListDatasetImportJobs(ctx context.Context, params *ListDatasetImportJobsInput, optFns ...func(*Options)) (*ListDatasetImportJobsOutput, error) {
if params == nil {
params = &ListDatasetImportJobsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDatasetImportJobs", params, optFns, c.addOperationListDatasetImportJobsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDatasetImportJobsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDatasetImportJobsInput struct {
// An array of filters. For each filter, you provide a condition and a match
// statement. The condition is either IS or IS_NOT , which specifies whether to
// include or exclude the datasets that match the statement from the list,
// respectively. The match statement consists of a key and a value. Filter
// properties
// - Condition - The condition to apply. Valid values are IS and IS_NOT . To
// include the datasets that match the statement, specify IS . To exclude
// matching datasets, specify IS_NOT .
// - Key - The name of the parameter to filter on. Valid values are DatasetArn
// and Status .
// - Value - The value to match.
// For example, to list all dataset import jobs whose status is ACTIVE, you
// specify the following filter: "Filters": [ { "Condition": "IS", "Key":
// "Status", "Value": "ACTIVE" } ]
Filters []types.Filter
// The number of items to return in the response.
MaxResults *int32
// If the result of the previous request was truncated, the response includes a
// NextToken . To retrieve the next set of results, use the token in the next
// request. Tokens expire after 24 hours.
NextToken *string
noSmithyDocumentSerde
}
type ListDatasetImportJobsOutput struct {
// An array of objects that summarize each dataset import job's properties.
DatasetImportJobs []types.DatasetImportJobSummary
// If the response is truncated, Amazon Forecast returns this token. To retrieve
// the next set of results, use the token in the next request.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDatasetImportJobsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListDatasetImportJobs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListDatasetImportJobs{}, 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 = addOpListDatasetImportJobsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListDatasetImportJobs(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
}
// ListDatasetImportJobsAPIClient is a client that implements the
// ListDatasetImportJobs operation.
type ListDatasetImportJobsAPIClient interface {
ListDatasetImportJobs(context.Context, *ListDatasetImportJobsInput, ...func(*Options)) (*ListDatasetImportJobsOutput, error)
}
var _ ListDatasetImportJobsAPIClient = (*Client)(nil)
// ListDatasetImportJobsPaginatorOptions is the paginator options for
// ListDatasetImportJobs
type ListDatasetImportJobsPaginatorOptions struct {
// The number of items 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
}
// ListDatasetImportJobsPaginator is a paginator for ListDatasetImportJobs
type ListDatasetImportJobsPaginator struct {
options ListDatasetImportJobsPaginatorOptions
client ListDatasetImportJobsAPIClient
params *ListDatasetImportJobsInput
nextToken *string
firstPage bool
}
// NewListDatasetImportJobsPaginator returns a new ListDatasetImportJobsPaginator
func NewListDatasetImportJobsPaginator(client ListDatasetImportJobsAPIClient, params *ListDatasetImportJobsInput, optFns ...func(*ListDatasetImportJobsPaginatorOptions)) *ListDatasetImportJobsPaginator {
if params == nil {
params = &ListDatasetImportJobsInput{}
}
options := ListDatasetImportJobsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListDatasetImportJobsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListDatasetImportJobsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListDatasetImportJobs page.
func (p *ListDatasetImportJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDatasetImportJobsOutput, 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.ListDatasetImportJobs(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_opListDatasetImportJobs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "ListDatasetImportJobs",
}
}
| 245 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of datasets created using the CreateDataset (https://docs.aws.amazon.com/forecast/latest/dg/API_CreateDataset.html)
// operation. For each dataset, a summary of its properties, including its Amazon
// Resource Name (ARN), is returned. To retrieve the complete set of properties,
// use the ARN with the DescribeDataset (https://docs.aws.amazon.com/forecast/latest/dg/API_DescribeDataset.html)
// operation.
func (c *Client) ListDatasets(ctx context.Context, params *ListDatasetsInput, optFns ...func(*Options)) (*ListDatasetsOutput, error) {
if params == nil {
params = &ListDatasetsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListDatasets", params, optFns, c.addOperationListDatasetsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListDatasetsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListDatasetsInput struct {
// The number of items to return in the response.
MaxResults *int32
// If the result of the previous request was truncated, the response includes a
// NextToken . To retrieve the next set of results, use the token in the next
// request. Tokens expire after 24 hours.
NextToken *string
noSmithyDocumentSerde
}
type ListDatasetsOutput struct {
// An array of objects that summarize each dataset's properties.
Datasets []types.DatasetSummary
// If the response is truncated, Amazon Forecast returns this token. To retrieve
// the next set of results, use the token in the next request.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListDatasetsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListDatasets{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListDatasets{}, 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_opListDatasets(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
}
// ListDatasetsAPIClient is a client that implements the ListDatasets operation.
type ListDatasetsAPIClient interface {
ListDatasets(context.Context, *ListDatasetsInput, ...func(*Options)) (*ListDatasetsOutput, error)
}
var _ ListDatasetsAPIClient = (*Client)(nil)
// ListDatasetsPaginatorOptions is the paginator options for ListDatasets
type ListDatasetsPaginatorOptions struct {
// The number of items 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
}
// ListDatasetsPaginator is a paginator for ListDatasets
type ListDatasetsPaginator struct {
options ListDatasetsPaginatorOptions
client ListDatasetsAPIClient
params *ListDatasetsInput
nextToken *string
firstPage bool
}
// NewListDatasetsPaginator returns a new ListDatasetsPaginator
func NewListDatasetsPaginator(client ListDatasetsAPIClient, params *ListDatasetsInput, optFns ...func(*ListDatasetsPaginatorOptions)) *ListDatasetsPaginator {
if params == nil {
params = &ListDatasetsInput{}
}
options := ListDatasetsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListDatasetsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListDatasetsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListDatasets page.
func (p *ListDatasetsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDatasetsOutput, 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.ListDatasets(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_opListDatasets(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "ListDatasets",
}
}
| 223 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of Explainability resources created using the
// CreateExplainability operation. This operation returns a summary for each
// Explainability. You can filter the list using an array of Filter objects. To
// retrieve the complete set of properties for a particular Explainability
// resource, use the ARN with the DescribeExplainability operation.
func (c *Client) ListExplainabilities(ctx context.Context, params *ListExplainabilitiesInput, optFns ...func(*Options)) (*ListExplainabilitiesOutput, error) {
if params == nil {
params = &ListExplainabilitiesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListExplainabilities", params, optFns, c.addOperationListExplainabilitiesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListExplainabilitiesOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListExplainabilitiesInput struct {
// An array of filters. For each filter, provide a condition and a match
// statement. The condition is either IS or IS_NOT , which specifies whether to
// include or exclude the resources that match the statement from the list. The
// match statement consists of a key and a value. Filter properties
// - Condition - The condition to apply. Valid values are IS and IS_NOT .
// - Key - The name of the parameter to filter on. Valid values are ResourceArn
// and Status .
// - Value - The value to match.
Filters []types.Filter
// The number of items returned in the response.
MaxResults *int32
// If the result of the previous request was truncated, the response includes a
// NextToken. To retrieve the next set of results, use the token in the next
// request. Tokens expire after 24 hours.
NextToken *string
noSmithyDocumentSerde
}
type ListExplainabilitiesOutput struct {
// An array of objects that summarize the properties of each Explainability
// resource.
Explainabilities []types.ExplainabilitySummary
// Returns this token if the response is truncated. To retrieve the next set of
// results, use the token in the next request.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListExplainabilitiesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListExplainabilities{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListExplainabilities{}, 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 = addOpListExplainabilitiesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListExplainabilities(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
}
// ListExplainabilitiesAPIClient is a client that implements the
// ListExplainabilities operation.
type ListExplainabilitiesAPIClient interface {
ListExplainabilities(context.Context, *ListExplainabilitiesInput, ...func(*Options)) (*ListExplainabilitiesOutput, error)
}
var _ ListExplainabilitiesAPIClient = (*Client)(nil)
// ListExplainabilitiesPaginatorOptions is the paginator options for
// ListExplainabilities
type ListExplainabilitiesPaginatorOptions struct {
// The number of items returned 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
}
// ListExplainabilitiesPaginator is a paginator for ListExplainabilities
type ListExplainabilitiesPaginator struct {
options ListExplainabilitiesPaginatorOptions
client ListExplainabilitiesAPIClient
params *ListExplainabilitiesInput
nextToken *string
firstPage bool
}
// NewListExplainabilitiesPaginator returns a new ListExplainabilitiesPaginator
func NewListExplainabilitiesPaginator(client ListExplainabilitiesAPIClient, params *ListExplainabilitiesInput, optFns ...func(*ListExplainabilitiesPaginatorOptions)) *ListExplainabilitiesPaginator {
if params == nil {
params = &ListExplainabilitiesInput{}
}
options := ListExplainabilitiesPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListExplainabilitiesPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListExplainabilitiesPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListExplainabilities page.
func (p *ListExplainabilitiesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListExplainabilitiesOutput, 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.ListExplainabilities(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_opListExplainabilities(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "ListExplainabilities",
}
}
| 239 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of Explainability exports created using the
// CreateExplainabilityExport operation. This operation returns a summary for each
// Explainability export. You can filter the list using an array of Filter
// objects. To retrieve the complete set of properties for a particular
// Explainability export, use the ARN with the DescribeExplainability operation.
func (c *Client) ListExplainabilityExports(ctx context.Context, params *ListExplainabilityExportsInput, optFns ...func(*Options)) (*ListExplainabilityExportsOutput, error) {
if params == nil {
params = &ListExplainabilityExportsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListExplainabilityExports", params, optFns, c.addOperationListExplainabilityExportsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListExplainabilityExportsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListExplainabilityExportsInput struct {
// An array of filters. For each filter, provide a condition and a match
// statement. The condition is either IS or IS_NOT , which specifies whether to
// include or exclude resources that match the statement from the list. The match
// statement consists of a key and a value. Filter properties
// - Condition - The condition to apply. Valid values are IS and IS_NOT .
// - Key - The name of the parameter to filter on. Valid values are ResourceArn
// and Status .
// - Value - The value to match.
Filters []types.Filter
// The number of items to return in the response.
MaxResults *int32
// If the result of the previous request was truncated, the response includes a
// NextToken. To retrieve the next set of results, use the token in the next
// request. Tokens expire after 24 hours.
NextToken *string
noSmithyDocumentSerde
}
type ListExplainabilityExportsOutput struct {
// An array of objects that summarize the properties of each Explainability export.
ExplainabilityExports []types.ExplainabilityExportSummary
// Returns this token if the response is truncated. To retrieve the next set of
// results, use the token in the next request.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListExplainabilityExportsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListExplainabilityExports{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListExplainabilityExports{}, 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 = addOpListExplainabilityExportsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListExplainabilityExports(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
}
// ListExplainabilityExportsAPIClient is a client that implements the
// ListExplainabilityExports operation.
type ListExplainabilityExportsAPIClient interface {
ListExplainabilityExports(context.Context, *ListExplainabilityExportsInput, ...func(*Options)) (*ListExplainabilityExportsOutput, error)
}
var _ ListExplainabilityExportsAPIClient = (*Client)(nil)
// ListExplainabilityExportsPaginatorOptions is the paginator options for
// ListExplainabilityExports
type ListExplainabilityExportsPaginatorOptions struct {
// The number of items 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
}
// ListExplainabilityExportsPaginator is a paginator for ListExplainabilityExports
type ListExplainabilityExportsPaginator struct {
options ListExplainabilityExportsPaginatorOptions
client ListExplainabilityExportsAPIClient
params *ListExplainabilityExportsInput
nextToken *string
firstPage bool
}
// NewListExplainabilityExportsPaginator returns a new
// ListExplainabilityExportsPaginator
func NewListExplainabilityExportsPaginator(client ListExplainabilityExportsAPIClient, params *ListExplainabilityExportsInput, optFns ...func(*ListExplainabilityExportsPaginatorOptions)) *ListExplainabilityExportsPaginator {
if params == nil {
params = &ListExplainabilityExportsInput{}
}
options := ListExplainabilityExportsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListExplainabilityExportsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListExplainabilityExportsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListExplainabilityExports page.
func (p *ListExplainabilityExportsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListExplainabilityExportsOutput, 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.ListExplainabilityExports(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_opListExplainabilityExports(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "ListExplainabilityExports",
}
}
| 239 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of forecast export jobs created using the CreateForecastExportJob
// operation. For each forecast export job, this operation returns a summary of its
// properties, including its Amazon Resource Name (ARN). To retrieve the complete
// set of properties, use the ARN with the DescribeForecastExportJob operation.
// You can filter the list using an array of Filter objects.
func (c *Client) ListForecastExportJobs(ctx context.Context, params *ListForecastExportJobsInput, optFns ...func(*Options)) (*ListForecastExportJobsOutput, error) {
if params == nil {
params = &ListForecastExportJobsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListForecastExportJobs", params, optFns, c.addOperationListForecastExportJobsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListForecastExportJobsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListForecastExportJobsInput struct {
// An array of filters. For each filter, you provide a condition and a match
// statement. The condition is either IS or IS_NOT , which specifies whether to
// include or exclude the forecast export jobs that match the statement from the
// list, respectively. The match statement consists of a key and a value. Filter
// properties
// - Condition - The condition to apply. Valid values are IS and IS_NOT . To
// include the forecast export jobs that match the statement, specify IS . To
// exclude matching forecast export jobs, specify IS_NOT .
// - Key - The name of the parameter to filter on. Valid values are ForecastArn
// and Status .
// - Value - The value to match.
// For example, to list all jobs that export a forecast named electricityforecast,
// specify the following filter: "Filters": [ { "Condition": "IS", "Key":
// "ForecastArn", "Value":
// "arn:aws:forecast:us-west-2::forecast/electricityforecast" } ]
Filters []types.Filter
// The number of items to return in the response.
MaxResults *int32
// If the result of the previous request was truncated, the response includes a
// NextToken . To retrieve the next set of results, use the token in the next
// request. Tokens expire after 24 hours.
NextToken *string
noSmithyDocumentSerde
}
type ListForecastExportJobsOutput struct {
// An array of objects that summarize each export job's properties.
ForecastExportJobs []types.ForecastExportJobSummary
// If the response is truncated, Amazon Forecast returns this token. To retrieve
// the next set of results, use the token in the next request.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListForecastExportJobsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListForecastExportJobs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListForecastExportJobs{}, 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 = addOpListForecastExportJobsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListForecastExportJobs(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
}
// ListForecastExportJobsAPIClient is a client that implements the
// ListForecastExportJobs operation.
type ListForecastExportJobsAPIClient interface {
ListForecastExportJobs(context.Context, *ListForecastExportJobsInput, ...func(*Options)) (*ListForecastExportJobsOutput, error)
}
var _ ListForecastExportJobsAPIClient = (*Client)(nil)
// ListForecastExportJobsPaginatorOptions is the paginator options for
// ListForecastExportJobs
type ListForecastExportJobsPaginatorOptions struct {
// The number of items 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
}
// ListForecastExportJobsPaginator is a paginator for ListForecastExportJobs
type ListForecastExportJobsPaginator struct {
options ListForecastExportJobsPaginatorOptions
client ListForecastExportJobsAPIClient
params *ListForecastExportJobsInput
nextToken *string
firstPage bool
}
// NewListForecastExportJobsPaginator returns a new ListForecastExportJobsPaginator
func NewListForecastExportJobsPaginator(client ListForecastExportJobsAPIClient, params *ListForecastExportJobsInput, optFns ...func(*ListForecastExportJobsPaginatorOptions)) *ListForecastExportJobsPaginator {
if params == nil {
params = &ListForecastExportJobsInput{}
}
options := ListForecastExportJobsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListForecastExportJobsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListForecastExportJobsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListForecastExportJobs page.
func (p *ListForecastExportJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListForecastExportJobsOutput, 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.ListForecastExportJobs(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_opListForecastExportJobs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "ListForecastExportJobs",
}
}
| 245 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of forecasts created using the CreateForecast operation. For
// each forecast, this operation returns a summary of its properties, including its
// Amazon Resource Name (ARN). To retrieve the complete set of properties, specify
// the ARN with the DescribeForecast operation. You can filter the list using an
// array of Filter objects.
func (c *Client) ListForecasts(ctx context.Context, params *ListForecastsInput, optFns ...func(*Options)) (*ListForecastsOutput, error) {
if params == nil {
params = &ListForecastsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListForecasts", params, optFns, c.addOperationListForecastsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListForecastsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListForecastsInput struct {
// An array of filters. For each filter, you provide a condition and a match
// statement. The condition is either IS or IS_NOT , which specifies whether to
// include or exclude the forecasts that match the statement from the list,
// respectively. The match statement consists of a key and a value. Filter
// properties
// - Condition - The condition to apply. Valid values are IS and IS_NOT . To
// include the forecasts that match the statement, specify IS . To exclude
// matching forecasts, specify IS_NOT .
// - Key - The name of the parameter to filter on. Valid values are
// DatasetGroupArn , PredictorArn , and Status .
// - Value - The value to match.
// For example, to list all forecasts whose status is not ACTIVE, you would
// specify: "Filters": [ { "Condition": "IS_NOT", "Key": "Status", "Value":
// "ACTIVE" } ]
Filters []types.Filter
// The number of items to return in the response.
MaxResults *int32
// If the result of the previous request was truncated, the response includes a
// NextToken . To retrieve the next set of results, use the token in the next
// request. Tokens expire after 24 hours.
NextToken *string
noSmithyDocumentSerde
}
type ListForecastsOutput struct {
// An array of objects that summarize each forecast's properties.
Forecasts []types.ForecastSummary
// If the response is truncated, Amazon Forecast returns this token. To retrieve
// the next set of results, use the token in the next request.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListForecastsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListForecasts{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListForecasts{}, 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 = addOpListForecastsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListForecasts(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
}
// ListForecastsAPIClient is a client that implements the ListForecasts operation.
type ListForecastsAPIClient interface {
ListForecasts(context.Context, *ListForecastsInput, ...func(*Options)) (*ListForecastsOutput, error)
}
var _ ListForecastsAPIClient = (*Client)(nil)
// ListForecastsPaginatorOptions is the paginator options for ListForecasts
type ListForecastsPaginatorOptions struct {
// The number of items 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
}
// ListForecastsPaginator is a paginator for ListForecasts
type ListForecastsPaginator struct {
options ListForecastsPaginatorOptions
client ListForecastsAPIClient
params *ListForecastsInput
nextToken *string
firstPage bool
}
// NewListForecastsPaginator returns a new ListForecastsPaginator
func NewListForecastsPaginator(client ListForecastsAPIClient, params *ListForecastsInput, optFns ...func(*ListForecastsPaginatorOptions)) *ListForecastsPaginator {
if params == nil {
params = &ListForecastsInput{}
}
options := ListForecastsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListForecastsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListForecastsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListForecasts page.
func (p *ListForecastsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListForecastsOutput, 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.ListForecasts(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_opListForecasts(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "ListForecasts",
}
}
| 242 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of the monitoring evaluation results and predictor events
// collected by the monitor resource during different windows of time. For
// information about monitoring see predictor-monitoring . For more information
// about retrieving monitoring results see Viewing Monitoring Results (https://docs.aws.amazon.com/forecast/latest/dg/predictor-monitoring-results.html)
// .
func (c *Client) ListMonitorEvaluations(ctx context.Context, params *ListMonitorEvaluationsInput, optFns ...func(*Options)) (*ListMonitorEvaluationsOutput, error) {
if params == nil {
params = &ListMonitorEvaluationsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListMonitorEvaluations", params, optFns, c.addOperationListMonitorEvaluationsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListMonitorEvaluationsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListMonitorEvaluationsInput struct {
// The Amazon Resource Name (ARN) of the monitor resource to get results from.
//
// This member is required.
MonitorArn *string
// An array of filters. For each filter, provide a condition and a match
// statement. The condition is either IS or IS_NOT , which specifies whether to
// include or exclude the resources that match the statement from the list. The
// match statement consists of a key and a value. Filter properties
// - Condition - The condition to apply. Valid values are IS and IS_NOT .
// - Key - The name of the parameter to filter on. The only valid value is
// EvaluationState .
// - Value - The value to match. Valid values are only SUCCESS or FAILURE .
// For example, to list only successful monitor evaluations, you would specify:
// "Filters": [ { "Condition": "IS", "Key": "EvaluationState", "Value": "SUCCESS" }
// ]
Filters []types.Filter
// The maximum number of monitoring results to return.
MaxResults *int32
// If the result of the previous request was truncated, the response includes a
// NextToken . To retrieve the next set of results, use the token in the next
// request. Tokens expire after 24 hours.
NextToken *string
noSmithyDocumentSerde
}
type ListMonitorEvaluationsOutput struct {
// If the response is truncated, Amazon Forecast returns this token. To retrieve
// the next set of results, use the token in the next request. Tokens expire after
// 24 hours.
NextToken *string
// The monitoring results and predictor events collected by the monitor resource
// during different windows of time. For information about monitoring see Viewing
// Monitoring Results (https://docs.aws.amazon.com/forecast/latest/dg/predictor-monitoring-results.html)
// . For more information about retrieving monitoring results see Viewing
// Monitoring Results (https://docs.aws.amazon.com/forecast/latest/dg/predictor-monitoring-results.html)
// .
PredictorMonitorEvaluations []types.PredictorMonitorEvaluation
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListMonitorEvaluationsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListMonitorEvaluations{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListMonitorEvaluations{}, 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 = addOpListMonitorEvaluationsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListMonitorEvaluations(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
}
// ListMonitorEvaluationsAPIClient is a client that implements the
// ListMonitorEvaluations operation.
type ListMonitorEvaluationsAPIClient interface {
ListMonitorEvaluations(context.Context, *ListMonitorEvaluationsInput, ...func(*Options)) (*ListMonitorEvaluationsOutput, error)
}
var _ ListMonitorEvaluationsAPIClient = (*Client)(nil)
// ListMonitorEvaluationsPaginatorOptions is the paginator options for
// ListMonitorEvaluations
type ListMonitorEvaluationsPaginatorOptions struct {
// The maximum number of monitoring results to return.
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
}
// ListMonitorEvaluationsPaginator is a paginator for ListMonitorEvaluations
type ListMonitorEvaluationsPaginator struct {
options ListMonitorEvaluationsPaginatorOptions
client ListMonitorEvaluationsAPIClient
params *ListMonitorEvaluationsInput
nextToken *string
firstPage bool
}
// NewListMonitorEvaluationsPaginator returns a new ListMonitorEvaluationsPaginator
func NewListMonitorEvaluationsPaginator(client ListMonitorEvaluationsAPIClient, params *ListMonitorEvaluationsInput, optFns ...func(*ListMonitorEvaluationsPaginatorOptions)) *ListMonitorEvaluationsPaginator {
if params == nil {
params = &ListMonitorEvaluationsInput{}
}
options := ListMonitorEvaluationsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListMonitorEvaluationsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListMonitorEvaluationsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListMonitorEvaluations page.
func (p *ListMonitorEvaluationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListMonitorEvaluationsOutput, 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.ListMonitorEvaluations(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_opListMonitorEvaluations(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "ListMonitorEvaluations",
}
}
| 252 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of monitors created with the CreateMonitor operation and
// CreateAutoPredictor operation. For each monitor resource, this operation returns
// of a summary of its properties, including its Amazon Resource Name (ARN). You
// can retrieve a complete set of properties of a monitor resource by specify the
// monitor's ARN in the DescribeMonitor operation.
func (c *Client) ListMonitors(ctx context.Context, params *ListMonitorsInput, optFns ...func(*Options)) (*ListMonitorsOutput, error) {
if params == nil {
params = &ListMonitorsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListMonitors", params, optFns, c.addOperationListMonitorsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListMonitorsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListMonitorsInput struct {
// An array of filters. For each filter, provide a condition and a match
// statement. The condition is either IS or IS_NOT , which specifies whether to
// include or exclude the resources that match the statement from the list. The
// match statement consists of a key and a value. Filter properties
// - Condition - The condition to apply. Valid values are IS and IS_NOT .
// - Key - The name of the parameter to filter on. The only valid value is Status
// .
// - Value - The value to match.
// For example, to list all monitors who's status is ACTIVE, you would specify:
// "Filters": [ { "Condition": "IS", "Key": "Status", "Value": "ACTIVE" } ]
Filters []types.Filter
// The maximum number of monitors to include in the response.
MaxResults *int32
// If the result of the previous request was truncated, the response includes a
// NextToken . To retrieve the next set of results, use the token in the next
// request. Tokens expire after 24 hours.
NextToken *string
noSmithyDocumentSerde
}
type ListMonitorsOutput struct {
// An array of objects that summarize each monitor's properties.
Monitors []types.MonitorSummary
// If the response is truncated, Amazon Forecast returns this token. To retrieve
// the next set of results, use the token in the next request.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListMonitorsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListMonitors{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListMonitors{}, 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 = addOpListMonitorsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListMonitors(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
}
// ListMonitorsAPIClient is a client that implements the ListMonitors operation.
type ListMonitorsAPIClient interface {
ListMonitors(context.Context, *ListMonitorsInput, ...func(*Options)) (*ListMonitorsOutput, error)
}
var _ ListMonitorsAPIClient = (*Client)(nil)
// ListMonitorsPaginatorOptions is the paginator options for ListMonitors
type ListMonitorsPaginatorOptions struct {
// The maximum number of monitors to include 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
}
// ListMonitorsPaginator is a paginator for ListMonitors
type ListMonitorsPaginator struct {
options ListMonitorsPaginatorOptions
client ListMonitorsAPIClient
params *ListMonitorsInput
nextToken *string
firstPage bool
}
// NewListMonitorsPaginator returns a new ListMonitorsPaginator
func NewListMonitorsPaginator(client ListMonitorsAPIClient, params *ListMonitorsInput, optFns ...func(*ListMonitorsPaginatorOptions)) *ListMonitorsPaginator {
if params == nil {
params = &ListMonitorsInput{}
}
options := ListMonitorsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListMonitorsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListMonitorsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListMonitors page.
func (p *ListMonitorsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListMonitorsOutput, 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.ListMonitors(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_opListMonitors(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "ListMonitors",
}
}
| 238 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package forecast
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/forecast/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a list of predictor backtest export jobs created using the
// CreatePredictorBacktestExportJob operation. This operation returns a summary for
// each backtest export job. You can filter the list using an array of Filter
// objects. To retrieve the complete set of properties for a particular backtest
// export job, use the ARN with the DescribePredictorBacktestExportJob operation.
func (c *Client) ListPredictorBacktestExportJobs(ctx context.Context, params *ListPredictorBacktestExportJobsInput, optFns ...func(*Options)) (*ListPredictorBacktestExportJobsOutput, error) {
if params == nil {
params = &ListPredictorBacktestExportJobsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListPredictorBacktestExportJobs", params, optFns, c.addOperationListPredictorBacktestExportJobsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListPredictorBacktestExportJobsOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListPredictorBacktestExportJobsInput struct {
// An array of filters. For each filter, provide a condition and a match
// statement. The condition is either IS or IS_NOT , which specifies whether to
// include or exclude the predictor backtest export jobs that match the statement
// from the list. The match statement consists of a key and a value. Filter
// properties
// - Condition - The condition to apply. Valid values are IS and IS_NOT . To
// include the predictor backtest export jobs that match the statement, specify
// IS . To exclude matching predictor backtest export jobs, specify IS_NOT .
// - Key - The name of the parameter to filter on. Valid values are PredictorArn
// and Status .
// - Value - The value to match.
Filters []types.Filter
// The number of items to return in the response.
MaxResults *int32
// If the result of the previous request was truncated, the response includes a
// NextToken. To retrieve the next set of results, use the token in the next
// request. Tokens expire after 24 hours.
NextToken *string
noSmithyDocumentSerde
}
type ListPredictorBacktestExportJobsOutput struct {
// Returns this token if the response is truncated. To retrieve the next set of
// results, use the token in the next request.
NextToken *string
// An array of objects that summarize the properties of each predictor backtest
// export job.
PredictorBacktestExportJobs []types.PredictorBacktestExportJobSummary
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListPredictorBacktestExportJobsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListPredictorBacktestExportJobs{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListPredictorBacktestExportJobs{}, 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 = addOpListPredictorBacktestExportJobsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListPredictorBacktestExportJobs(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
}
// ListPredictorBacktestExportJobsAPIClient is a client that implements the
// ListPredictorBacktestExportJobs operation.
type ListPredictorBacktestExportJobsAPIClient interface {
ListPredictorBacktestExportJobs(context.Context, *ListPredictorBacktestExportJobsInput, ...func(*Options)) (*ListPredictorBacktestExportJobsOutput, error)
}
var _ ListPredictorBacktestExportJobsAPIClient = (*Client)(nil)
// ListPredictorBacktestExportJobsPaginatorOptions is the paginator options for
// ListPredictorBacktestExportJobs
type ListPredictorBacktestExportJobsPaginatorOptions struct {
// The number of items 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
}
// ListPredictorBacktestExportJobsPaginator is a paginator for
// ListPredictorBacktestExportJobs
type ListPredictorBacktestExportJobsPaginator struct {
options ListPredictorBacktestExportJobsPaginatorOptions
client ListPredictorBacktestExportJobsAPIClient
params *ListPredictorBacktestExportJobsInput
nextToken *string
firstPage bool
}
// NewListPredictorBacktestExportJobsPaginator returns a new
// ListPredictorBacktestExportJobsPaginator
func NewListPredictorBacktestExportJobsPaginator(client ListPredictorBacktestExportJobsAPIClient, params *ListPredictorBacktestExportJobsInput, optFns ...func(*ListPredictorBacktestExportJobsPaginatorOptions)) *ListPredictorBacktestExportJobsPaginator {
if params == nil {
params = &ListPredictorBacktestExportJobsInput{}
}
options := ListPredictorBacktestExportJobsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListPredictorBacktestExportJobsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListPredictorBacktestExportJobsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListPredictorBacktestExportJobs page.
func (p *ListPredictorBacktestExportJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListPredictorBacktestExportJobsOutput, 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.ListPredictorBacktestExportJobs(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_opListPredictorBacktestExportJobs(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "forecast",
OperationName: "ListPredictorBacktestExportJobs",
}
}
| 244 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.