service/storagegateway/validators.go (3,386 lines of code) (raw):
// Code generated by smithy-go-codegen DO NOT EDIT.
package storagegateway
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/storagegateway/types"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
)
type validateOpActivateGateway struct {
}
func (*validateOpActivateGateway) ID() string {
return "OperationInputValidation"
}
func (m *validateOpActivateGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ActivateGatewayInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpActivateGatewayInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpAddCache struct {
}
func (*validateOpAddCache) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAddCache) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AddCacheInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAddCacheInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpAddTagsToResource struct {
}
func (*validateOpAddTagsToResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAddTagsToResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AddTagsToResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAddTagsToResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpAddUploadBuffer struct {
}
func (*validateOpAddUploadBuffer) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAddUploadBuffer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AddUploadBufferInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAddUploadBufferInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpAddWorkingStorage struct {
}
func (*validateOpAddWorkingStorage) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAddWorkingStorage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AddWorkingStorageInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAddWorkingStorageInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpAssignTapePool struct {
}
func (*validateOpAssignTapePool) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAssignTapePool) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AssignTapePoolInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAssignTapePoolInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpAssociateFileSystem struct {
}
func (*validateOpAssociateFileSystem) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAssociateFileSystem) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AssociateFileSystemInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAssociateFileSystemInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpAttachVolume struct {
}
func (*validateOpAttachVolume) ID() string {
return "OperationInputValidation"
}
func (m *validateOpAttachVolume) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*AttachVolumeInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpAttachVolumeInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCancelArchival struct {
}
func (*validateOpCancelArchival) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCancelArchival) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CancelArchivalInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCancelArchivalInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCancelCacheReport struct {
}
func (*validateOpCancelCacheReport) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCancelCacheReport) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CancelCacheReportInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCancelCacheReportInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCancelRetrieval struct {
}
func (*validateOpCancelRetrieval) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCancelRetrieval) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CancelRetrievalInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCancelRetrievalInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateCachediSCSIVolume struct {
}
func (*validateOpCreateCachediSCSIVolume) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateCachediSCSIVolume) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateCachediSCSIVolumeInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateCachediSCSIVolumeInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateNFSFileShare struct {
}
func (*validateOpCreateNFSFileShare) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateNFSFileShare) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateNFSFileShareInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateNFSFileShareInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateSMBFileShare struct {
}
func (*validateOpCreateSMBFileShare) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateSMBFileShare) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateSMBFileShareInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateSMBFileShareInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateSnapshotFromVolumeRecoveryPoint struct {
}
func (*validateOpCreateSnapshotFromVolumeRecoveryPoint) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateSnapshotFromVolumeRecoveryPoint) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateSnapshotFromVolumeRecoveryPointInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateSnapshotFromVolumeRecoveryPointInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateSnapshot struct {
}
func (*validateOpCreateSnapshot) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateSnapshot) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateSnapshotInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateSnapshotInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateStorediSCSIVolume struct {
}
func (*validateOpCreateStorediSCSIVolume) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateStorediSCSIVolume) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateStorediSCSIVolumeInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateStorediSCSIVolumeInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateTapePool struct {
}
func (*validateOpCreateTapePool) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateTapePool) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateTapePoolInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateTapePoolInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateTapes struct {
}
func (*validateOpCreateTapes) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateTapes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateTapesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateTapesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpCreateTapeWithBarcode struct {
}
func (*validateOpCreateTapeWithBarcode) ID() string {
return "OperationInputValidation"
}
func (m *validateOpCreateTapeWithBarcode) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*CreateTapeWithBarcodeInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpCreateTapeWithBarcodeInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteAutomaticTapeCreationPolicy struct {
}
func (*validateOpDeleteAutomaticTapeCreationPolicy) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteAutomaticTapeCreationPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteAutomaticTapeCreationPolicyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteAutomaticTapeCreationPolicyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteBandwidthRateLimit struct {
}
func (*validateOpDeleteBandwidthRateLimit) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteBandwidthRateLimit) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteBandwidthRateLimitInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteBandwidthRateLimitInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteCacheReport struct {
}
func (*validateOpDeleteCacheReport) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteCacheReport) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteCacheReportInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteCacheReportInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteChapCredentials struct {
}
func (*validateOpDeleteChapCredentials) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteChapCredentials) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteChapCredentialsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteChapCredentialsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteFileShare struct {
}
func (*validateOpDeleteFileShare) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteFileShare) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteFileShareInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteFileShareInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteGateway struct {
}
func (*validateOpDeleteGateway) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteGatewayInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteGatewayInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteSnapshotSchedule struct {
}
func (*validateOpDeleteSnapshotSchedule) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteSnapshotSchedule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteSnapshotScheduleInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteSnapshotScheduleInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteTapeArchive struct {
}
func (*validateOpDeleteTapeArchive) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteTapeArchive) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteTapeArchiveInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteTapeArchiveInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteTape struct {
}
func (*validateOpDeleteTape) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteTape) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteTapeInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteTapeInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteTapePool struct {
}
func (*validateOpDeleteTapePool) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteTapePool) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteTapePoolInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteTapePoolInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDeleteVolume struct {
}
func (*validateOpDeleteVolume) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDeleteVolume) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DeleteVolumeInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDeleteVolumeInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeAvailabilityMonitorTest struct {
}
func (*validateOpDescribeAvailabilityMonitorTest) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeAvailabilityMonitorTest) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeAvailabilityMonitorTestInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeAvailabilityMonitorTestInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeBandwidthRateLimit struct {
}
func (*validateOpDescribeBandwidthRateLimit) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeBandwidthRateLimit) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeBandwidthRateLimitInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeBandwidthRateLimitInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeBandwidthRateLimitSchedule struct {
}
func (*validateOpDescribeBandwidthRateLimitSchedule) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeBandwidthRateLimitSchedule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeBandwidthRateLimitScheduleInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeBandwidthRateLimitScheduleInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeCachediSCSIVolumes struct {
}
func (*validateOpDescribeCachediSCSIVolumes) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeCachediSCSIVolumes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeCachediSCSIVolumesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeCachediSCSIVolumesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeCache struct {
}
func (*validateOpDescribeCache) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeCache) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeCacheInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeCacheInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeCacheReport struct {
}
func (*validateOpDescribeCacheReport) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeCacheReport) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeCacheReportInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeCacheReportInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeChapCredentials struct {
}
func (*validateOpDescribeChapCredentials) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeChapCredentials) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeChapCredentialsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeChapCredentialsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeFileSystemAssociations struct {
}
func (*validateOpDescribeFileSystemAssociations) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeFileSystemAssociations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeFileSystemAssociationsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeFileSystemAssociationsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeGatewayInformation struct {
}
func (*validateOpDescribeGatewayInformation) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeGatewayInformation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeGatewayInformationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeGatewayInformationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeMaintenanceStartTime struct {
}
func (*validateOpDescribeMaintenanceStartTime) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeMaintenanceStartTime) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeMaintenanceStartTimeInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeMaintenanceStartTimeInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeNFSFileShares struct {
}
func (*validateOpDescribeNFSFileShares) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeNFSFileShares) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeNFSFileSharesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeNFSFileSharesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeSMBFileShares struct {
}
func (*validateOpDescribeSMBFileShares) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeSMBFileShares) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeSMBFileSharesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeSMBFileSharesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeSMBSettings struct {
}
func (*validateOpDescribeSMBSettings) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeSMBSettings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeSMBSettingsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeSMBSettingsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeSnapshotSchedule struct {
}
func (*validateOpDescribeSnapshotSchedule) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeSnapshotSchedule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeSnapshotScheduleInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeSnapshotScheduleInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeStorediSCSIVolumes struct {
}
func (*validateOpDescribeStorediSCSIVolumes) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeStorediSCSIVolumes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeStorediSCSIVolumesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeStorediSCSIVolumesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeTapeRecoveryPoints struct {
}
func (*validateOpDescribeTapeRecoveryPoints) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeTapeRecoveryPoints) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeTapeRecoveryPointsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeTapeRecoveryPointsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeTapes struct {
}
func (*validateOpDescribeTapes) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeTapes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeTapesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeTapesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeUploadBuffer struct {
}
func (*validateOpDescribeUploadBuffer) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeUploadBuffer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeUploadBufferInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeUploadBufferInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeVTLDevices struct {
}
func (*validateOpDescribeVTLDevices) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeVTLDevices) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeVTLDevicesInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeVTLDevicesInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDescribeWorkingStorage struct {
}
func (*validateOpDescribeWorkingStorage) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDescribeWorkingStorage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DescribeWorkingStorageInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDescribeWorkingStorageInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDetachVolume struct {
}
func (*validateOpDetachVolume) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDetachVolume) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DetachVolumeInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDetachVolumeInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDisableGateway struct {
}
func (*validateOpDisableGateway) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDisableGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DisableGatewayInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDisableGatewayInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpDisassociateFileSystem struct {
}
func (*validateOpDisassociateFileSystem) ID() string {
return "OperationInputValidation"
}
func (m *validateOpDisassociateFileSystem) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*DisassociateFileSystemInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpDisassociateFileSystemInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpEvictFilesFailingUpload struct {
}
func (*validateOpEvictFilesFailingUpload) ID() string {
return "OperationInputValidation"
}
func (m *validateOpEvictFilesFailingUpload) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*EvictFilesFailingUploadInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpEvictFilesFailingUploadInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpJoinDomain struct {
}
func (*validateOpJoinDomain) ID() string {
return "OperationInputValidation"
}
func (m *validateOpJoinDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*JoinDomainInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpJoinDomainInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListLocalDisks struct {
}
func (*validateOpListLocalDisks) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListLocalDisks) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListLocalDisksInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListLocalDisksInput(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 validateOpListVolumeInitiators struct {
}
func (*validateOpListVolumeInitiators) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListVolumeInitiators) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListVolumeInitiatorsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListVolumeInitiatorsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpListVolumeRecoveryPoints struct {
}
func (*validateOpListVolumeRecoveryPoints) ID() string {
return "OperationInputValidation"
}
func (m *validateOpListVolumeRecoveryPoints) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ListVolumeRecoveryPointsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpListVolumeRecoveryPointsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpNotifyWhenUploaded struct {
}
func (*validateOpNotifyWhenUploaded) ID() string {
return "OperationInputValidation"
}
func (m *validateOpNotifyWhenUploaded) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*NotifyWhenUploadedInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpNotifyWhenUploadedInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpRefreshCache struct {
}
func (*validateOpRefreshCache) ID() string {
return "OperationInputValidation"
}
func (m *validateOpRefreshCache) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*RefreshCacheInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpRefreshCacheInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpRemoveTagsFromResource struct {
}
func (*validateOpRemoveTagsFromResource) ID() string {
return "OperationInputValidation"
}
func (m *validateOpRemoveTagsFromResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*RemoveTagsFromResourceInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpRemoveTagsFromResourceInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpResetCache struct {
}
func (*validateOpResetCache) ID() string {
return "OperationInputValidation"
}
func (m *validateOpResetCache) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ResetCacheInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpResetCacheInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpRetrieveTapeArchive struct {
}
func (*validateOpRetrieveTapeArchive) ID() string {
return "OperationInputValidation"
}
func (m *validateOpRetrieveTapeArchive) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*RetrieveTapeArchiveInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpRetrieveTapeArchiveInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpRetrieveTapeRecoveryPoint struct {
}
func (*validateOpRetrieveTapeRecoveryPoint) ID() string {
return "OperationInputValidation"
}
func (m *validateOpRetrieveTapeRecoveryPoint) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*RetrieveTapeRecoveryPointInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpRetrieveTapeRecoveryPointInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpSetLocalConsolePassword struct {
}
func (*validateOpSetLocalConsolePassword) ID() string {
return "OperationInputValidation"
}
func (m *validateOpSetLocalConsolePassword) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*SetLocalConsolePasswordInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpSetLocalConsolePasswordInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpSetSMBGuestPassword struct {
}
func (*validateOpSetSMBGuestPassword) ID() string {
return "OperationInputValidation"
}
func (m *validateOpSetSMBGuestPassword) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*SetSMBGuestPasswordInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpSetSMBGuestPasswordInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpShutdownGateway struct {
}
func (*validateOpShutdownGateway) ID() string {
return "OperationInputValidation"
}
func (m *validateOpShutdownGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*ShutdownGatewayInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpShutdownGatewayInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartAvailabilityMonitorTest struct {
}
func (*validateOpStartAvailabilityMonitorTest) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartAvailabilityMonitorTest) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartAvailabilityMonitorTestInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartAvailabilityMonitorTestInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartCacheReport struct {
}
func (*validateOpStartCacheReport) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartCacheReport) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartCacheReportInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartCacheReportInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpStartGateway struct {
}
func (*validateOpStartGateway) ID() string {
return "OperationInputValidation"
}
func (m *validateOpStartGateway) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*StartGatewayInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpStartGatewayInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateAutomaticTapeCreationPolicy struct {
}
func (*validateOpUpdateAutomaticTapeCreationPolicy) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateAutomaticTapeCreationPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateAutomaticTapeCreationPolicyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateAutomaticTapeCreationPolicyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateBandwidthRateLimit struct {
}
func (*validateOpUpdateBandwidthRateLimit) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateBandwidthRateLimit) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateBandwidthRateLimitInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateBandwidthRateLimitInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateBandwidthRateLimitSchedule struct {
}
func (*validateOpUpdateBandwidthRateLimitSchedule) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateBandwidthRateLimitSchedule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateBandwidthRateLimitScheduleInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateBandwidthRateLimitScheduleInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateChapCredentials struct {
}
func (*validateOpUpdateChapCredentials) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateChapCredentials) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateChapCredentialsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateChapCredentialsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateFileSystemAssociation struct {
}
func (*validateOpUpdateFileSystemAssociation) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateFileSystemAssociation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateFileSystemAssociationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateFileSystemAssociationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateGatewayInformation struct {
}
func (*validateOpUpdateGatewayInformation) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateGatewayInformation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateGatewayInformationInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateGatewayInformationInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateGatewaySoftwareNow struct {
}
func (*validateOpUpdateGatewaySoftwareNow) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateGatewaySoftwareNow) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateGatewaySoftwareNowInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateGatewaySoftwareNowInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateMaintenanceStartTime struct {
}
func (*validateOpUpdateMaintenanceStartTime) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateMaintenanceStartTime) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateMaintenanceStartTimeInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateMaintenanceStartTimeInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateNFSFileShare struct {
}
func (*validateOpUpdateNFSFileShare) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateNFSFileShare) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateNFSFileShareInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateNFSFileShareInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateSMBFileShare struct {
}
func (*validateOpUpdateSMBFileShare) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateSMBFileShare) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateSMBFileShareInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateSMBFileShareInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateSMBFileShareVisibility struct {
}
func (*validateOpUpdateSMBFileShareVisibility) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateSMBFileShareVisibility) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateSMBFileShareVisibilityInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateSMBFileShareVisibilityInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateSMBLocalGroups struct {
}
func (*validateOpUpdateSMBLocalGroups) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateSMBLocalGroups) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateSMBLocalGroupsInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateSMBLocalGroupsInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateSMBSecurityStrategy struct {
}
func (*validateOpUpdateSMBSecurityStrategy) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateSMBSecurityStrategy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateSMBSecurityStrategyInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateSMBSecurityStrategyInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateSnapshotSchedule struct {
}
func (*validateOpUpdateSnapshotSchedule) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateSnapshotSchedule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateSnapshotScheduleInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateSnapshotScheduleInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
type validateOpUpdateVTLDeviceType struct {
}
func (*validateOpUpdateVTLDeviceType) ID() string {
return "OperationInputValidation"
}
func (m *validateOpUpdateVTLDeviceType) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input, ok := in.Parameters.(*UpdateVTLDeviceTypeInput)
if !ok {
return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
}
if err := validateOpUpdateVTLDeviceTypeInput(input); err != nil {
return out, metadata, err
}
return next.HandleInitialize(ctx, in)
}
func addOpActivateGatewayValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpActivateGateway{}, middleware.After)
}
func addOpAddCacheValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAddCache{}, middleware.After)
}
func addOpAddTagsToResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAddTagsToResource{}, middleware.After)
}
func addOpAddUploadBufferValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAddUploadBuffer{}, middleware.After)
}
func addOpAddWorkingStorageValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAddWorkingStorage{}, middleware.After)
}
func addOpAssignTapePoolValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAssignTapePool{}, middleware.After)
}
func addOpAssociateFileSystemValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAssociateFileSystem{}, middleware.After)
}
func addOpAttachVolumeValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAttachVolume{}, middleware.After)
}
func addOpCancelArchivalValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCancelArchival{}, middleware.After)
}
func addOpCancelCacheReportValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCancelCacheReport{}, middleware.After)
}
func addOpCancelRetrievalValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCancelRetrieval{}, middleware.After)
}
func addOpCreateCachediSCSIVolumeValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateCachediSCSIVolume{}, middleware.After)
}
func addOpCreateNFSFileShareValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateNFSFileShare{}, middleware.After)
}
func addOpCreateSMBFileShareValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateSMBFileShare{}, middleware.After)
}
func addOpCreateSnapshotFromVolumeRecoveryPointValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateSnapshotFromVolumeRecoveryPoint{}, middleware.After)
}
func addOpCreateSnapshotValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateSnapshot{}, middleware.After)
}
func addOpCreateStorediSCSIVolumeValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateStorediSCSIVolume{}, middleware.After)
}
func addOpCreateTapePoolValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateTapePool{}, middleware.After)
}
func addOpCreateTapesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateTapes{}, middleware.After)
}
func addOpCreateTapeWithBarcodeValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateTapeWithBarcode{}, middleware.After)
}
func addOpDeleteAutomaticTapeCreationPolicyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteAutomaticTapeCreationPolicy{}, middleware.After)
}
func addOpDeleteBandwidthRateLimitValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteBandwidthRateLimit{}, middleware.After)
}
func addOpDeleteCacheReportValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteCacheReport{}, middleware.After)
}
func addOpDeleteChapCredentialsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteChapCredentials{}, middleware.After)
}
func addOpDeleteFileShareValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteFileShare{}, middleware.After)
}
func addOpDeleteGatewayValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteGateway{}, middleware.After)
}
func addOpDeleteSnapshotScheduleValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteSnapshotSchedule{}, middleware.After)
}
func addOpDeleteTapeArchiveValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteTapeArchive{}, middleware.After)
}
func addOpDeleteTapeValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteTape{}, middleware.After)
}
func addOpDeleteTapePoolValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteTapePool{}, middleware.After)
}
func addOpDeleteVolumeValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteVolume{}, middleware.After)
}
func addOpDescribeAvailabilityMonitorTestValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeAvailabilityMonitorTest{}, middleware.After)
}
func addOpDescribeBandwidthRateLimitValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeBandwidthRateLimit{}, middleware.After)
}
func addOpDescribeBandwidthRateLimitScheduleValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeBandwidthRateLimitSchedule{}, middleware.After)
}
func addOpDescribeCachediSCSIVolumesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeCachediSCSIVolumes{}, middleware.After)
}
func addOpDescribeCacheValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeCache{}, middleware.After)
}
func addOpDescribeCacheReportValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeCacheReport{}, middleware.After)
}
func addOpDescribeChapCredentialsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeChapCredentials{}, middleware.After)
}
func addOpDescribeFileSystemAssociationsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeFileSystemAssociations{}, middleware.After)
}
func addOpDescribeGatewayInformationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeGatewayInformation{}, middleware.After)
}
func addOpDescribeMaintenanceStartTimeValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeMaintenanceStartTime{}, middleware.After)
}
func addOpDescribeNFSFileSharesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeNFSFileShares{}, middleware.After)
}
func addOpDescribeSMBFileSharesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeSMBFileShares{}, middleware.After)
}
func addOpDescribeSMBSettingsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeSMBSettings{}, middleware.After)
}
func addOpDescribeSnapshotScheduleValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeSnapshotSchedule{}, middleware.After)
}
func addOpDescribeStorediSCSIVolumesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeStorediSCSIVolumes{}, middleware.After)
}
func addOpDescribeTapeRecoveryPointsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeTapeRecoveryPoints{}, middleware.After)
}
func addOpDescribeTapesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeTapes{}, middleware.After)
}
func addOpDescribeUploadBufferValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeUploadBuffer{}, middleware.After)
}
func addOpDescribeVTLDevicesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeVTLDevices{}, middleware.After)
}
func addOpDescribeWorkingStorageValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDescribeWorkingStorage{}, middleware.After)
}
func addOpDetachVolumeValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDetachVolume{}, middleware.After)
}
func addOpDisableGatewayValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDisableGateway{}, middleware.After)
}
func addOpDisassociateFileSystemValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDisassociateFileSystem{}, middleware.After)
}
func addOpEvictFilesFailingUploadValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpEvictFilesFailingUpload{}, middleware.After)
}
func addOpJoinDomainValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpJoinDomain{}, middleware.After)
}
func addOpListLocalDisksValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListLocalDisks{}, middleware.After)
}
func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
}
func addOpListVolumeInitiatorsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListVolumeInitiators{}, middleware.After)
}
func addOpListVolumeRecoveryPointsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpListVolumeRecoveryPoints{}, middleware.After)
}
func addOpNotifyWhenUploadedValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpNotifyWhenUploaded{}, middleware.After)
}
func addOpRefreshCacheValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpRefreshCache{}, middleware.After)
}
func addOpRemoveTagsFromResourceValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpRemoveTagsFromResource{}, middleware.After)
}
func addOpResetCacheValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpResetCache{}, middleware.After)
}
func addOpRetrieveTapeArchiveValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpRetrieveTapeArchive{}, middleware.After)
}
func addOpRetrieveTapeRecoveryPointValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpRetrieveTapeRecoveryPoint{}, middleware.After)
}
func addOpSetLocalConsolePasswordValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpSetLocalConsolePassword{}, middleware.After)
}
func addOpSetSMBGuestPasswordValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpSetSMBGuestPassword{}, middleware.After)
}
func addOpShutdownGatewayValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpShutdownGateway{}, middleware.After)
}
func addOpStartAvailabilityMonitorTestValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartAvailabilityMonitorTest{}, middleware.After)
}
func addOpStartCacheReportValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartCacheReport{}, middleware.After)
}
func addOpStartGatewayValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpStartGateway{}, middleware.After)
}
func addOpUpdateAutomaticTapeCreationPolicyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateAutomaticTapeCreationPolicy{}, middleware.After)
}
func addOpUpdateBandwidthRateLimitValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateBandwidthRateLimit{}, middleware.After)
}
func addOpUpdateBandwidthRateLimitScheduleValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateBandwidthRateLimitSchedule{}, middleware.After)
}
func addOpUpdateChapCredentialsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateChapCredentials{}, middleware.After)
}
func addOpUpdateFileSystemAssociationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateFileSystemAssociation{}, middleware.After)
}
func addOpUpdateGatewayInformationValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateGatewayInformation{}, middleware.After)
}
func addOpUpdateGatewaySoftwareNowValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateGatewaySoftwareNow{}, middleware.After)
}
func addOpUpdateMaintenanceStartTimeValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateMaintenanceStartTime{}, middleware.After)
}
func addOpUpdateNFSFileShareValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateNFSFileShare{}, middleware.After)
}
func addOpUpdateSMBFileShareValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateSMBFileShare{}, middleware.After)
}
func addOpUpdateSMBFileShareVisibilityValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateSMBFileShareVisibility{}, middleware.After)
}
func addOpUpdateSMBLocalGroupsValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateSMBLocalGroups{}, middleware.After)
}
func addOpUpdateSMBSecurityStrategyValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateSMBSecurityStrategy{}, middleware.After)
}
func addOpUpdateSnapshotScheduleValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateSnapshotSchedule{}, middleware.After)
}
func addOpUpdateVTLDeviceTypeValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpUpdateVTLDeviceType{}, middleware.After)
}
func validateAutomaticTapeCreationRule(v *types.AutomaticTapeCreationRule) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AutomaticTapeCreationRule"}
if v.TapeBarcodePrefix == nil {
invalidParams.Add(smithy.NewErrParamRequired("TapeBarcodePrefix"))
}
if v.PoolId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PoolId"))
}
if v.TapeSizeInBytes == nil {
invalidParams.Add(smithy.NewErrParamRequired("TapeSizeInBytes"))
}
if v.MinimumNumTapes == nil {
invalidParams.Add(smithy.NewErrParamRequired("MinimumNumTapes"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateAutomaticTapeCreationRules(v []types.AutomaticTapeCreationRule) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AutomaticTapeCreationRules"}
for i := range v {
if err := validateAutomaticTapeCreationRule(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateBandwidthRateLimitInterval(v *types.BandwidthRateLimitInterval) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BandwidthRateLimitInterval"}
if v.StartHourOfDay == nil {
invalidParams.Add(smithy.NewErrParamRequired("StartHourOfDay"))
}
if v.StartMinuteOfHour == nil {
invalidParams.Add(smithy.NewErrParamRequired("StartMinuteOfHour"))
}
if v.EndHourOfDay == nil {
invalidParams.Add(smithy.NewErrParamRequired("EndHourOfDay"))
}
if v.EndMinuteOfHour == nil {
invalidParams.Add(smithy.NewErrParamRequired("EndMinuteOfHour"))
}
if v.DaysOfWeek == nil {
invalidParams.Add(smithy.NewErrParamRequired("DaysOfWeek"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateBandwidthRateLimitIntervals(v []types.BandwidthRateLimitInterval) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "BandwidthRateLimitIntervals"}
for i := range v {
if err := validateBandwidthRateLimitInterval(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCacheReportFilter(v *types.CacheReportFilter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CacheReportFilter"}
if len(v.Name) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("Name"))
}
if v.Values == nil {
invalidParams.Add(smithy.NewErrParamRequired("Values"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateCacheReportFilterList(v []types.CacheReportFilter) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CacheReportFilterList"}
for i := range v {
if err := validateCacheReportFilter(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTag(v *types.Tag) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Tag"}
if v.Key == nil {
invalidParams.Add(smithy.NewErrParamRequired("Key"))
}
if v.Value == nil {
invalidParams.Add(smithy.NewErrParamRequired("Value"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateTags(v []types.Tag) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "Tags"}
for i := range v {
if err := validateTag(&v[i]); err != nil {
invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpActivateGatewayInput(v *ActivateGatewayInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ActivateGatewayInput"}
if v.ActivationKey == nil {
invalidParams.Add(smithy.NewErrParamRequired("ActivationKey"))
}
if v.GatewayName == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayName"))
}
if v.GatewayTimezone == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayTimezone"))
}
if v.GatewayRegion == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayRegion"))
}
if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAddCacheInput(v *AddCacheInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AddCacheInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.DiskIds == nil {
invalidParams.Add(smithy.NewErrParamRequired("DiskIds"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAddTagsToResourceInput(v *AddTagsToResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AddTagsToResourceInput"}
if v.ResourceARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
}
if v.Tags == nil {
invalidParams.Add(smithy.NewErrParamRequired("Tags"))
} else if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAddUploadBufferInput(v *AddUploadBufferInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AddUploadBufferInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.DiskIds == nil {
invalidParams.Add(smithy.NewErrParamRequired("DiskIds"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAddWorkingStorageInput(v *AddWorkingStorageInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AddWorkingStorageInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.DiskIds == nil {
invalidParams.Add(smithy.NewErrParamRequired("DiskIds"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAssignTapePoolInput(v *AssignTapePoolInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AssignTapePoolInput"}
if v.TapeARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
}
if v.PoolId == nil {
invalidParams.Add(smithy.NewErrParamRequired("PoolId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAssociateFileSystemInput(v *AssociateFileSystemInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AssociateFileSystemInput"}
if v.UserName == nil {
invalidParams.Add(smithy.NewErrParamRequired("UserName"))
}
if v.Password == nil {
invalidParams.Add(smithy.NewErrParamRequired("Password"))
}
if v.ClientToken == nil {
invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.LocationARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("LocationARN"))
}
if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpAttachVolumeInput(v *AttachVolumeInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "AttachVolumeInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.VolumeARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("VolumeARN"))
}
if v.NetworkInterfaceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCancelArchivalInput(v *CancelArchivalInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CancelArchivalInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.TapeARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCancelCacheReportInput(v *CancelCacheReportInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CancelCacheReportInput"}
if v.CacheReportARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("CacheReportARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCancelRetrievalInput(v *CancelRetrievalInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CancelRetrievalInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.TapeARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateCachediSCSIVolumeInput(v *CreateCachediSCSIVolumeInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateCachediSCSIVolumeInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.TargetName == nil {
invalidParams.Add(smithy.NewErrParamRequired("TargetName"))
}
if v.NetworkInterfaceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
}
if v.ClientToken == nil {
invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
}
if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateNFSFileShareInput(v *CreateNFSFileShareInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateNFSFileShareInput"}
if v.ClientToken == nil {
invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.Role == nil {
invalidParams.Add(smithy.NewErrParamRequired("Role"))
}
if v.LocationARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("LocationARN"))
}
if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateSMBFileShareInput(v *CreateSMBFileShareInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateSMBFileShareInput"}
if v.ClientToken == nil {
invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.Role == nil {
invalidParams.Add(smithy.NewErrParamRequired("Role"))
}
if v.LocationARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("LocationARN"))
}
if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateSnapshotFromVolumeRecoveryPointInput(v *CreateSnapshotFromVolumeRecoveryPointInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateSnapshotFromVolumeRecoveryPointInput"}
if v.VolumeARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("VolumeARN"))
}
if v.SnapshotDescription == nil {
invalidParams.Add(smithy.NewErrParamRequired("SnapshotDescription"))
}
if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateSnapshotInput(v *CreateSnapshotInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateSnapshotInput"}
if v.VolumeARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("VolumeARN"))
}
if v.SnapshotDescription == nil {
invalidParams.Add(smithy.NewErrParamRequired("SnapshotDescription"))
}
if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateStorediSCSIVolumeInput(v *CreateStorediSCSIVolumeInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateStorediSCSIVolumeInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.DiskId == nil {
invalidParams.Add(smithy.NewErrParamRequired("DiskId"))
}
if v.TargetName == nil {
invalidParams.Add(smithy.NewErrParamRequired("TargetName"))
}
if v.NetworkInterfaceId == nil {
invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
}
if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateTapePoolInput(v *CreateTapePoolInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateTapePoolInput"}
if v.PoolName == nil {
invalidParams.Add(smithy.NewErrParamRequired("PoolName"))
}
if len(v.StorageClass) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("StorageClass"))
}
if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateTapesInput(v *CreateTapesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateTapesInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.TapeSizeInBytes == nil {
invalidParams.Add(smithy.NewErrParamRequired("TapeSizeInBytes"))
}
if v.ClientToken == nil {
invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
}
if v.NumTapesToCreate == nil {
invalidParams.Add(smithy.NewErrParamRequired("NumTapesToCreate"))
}
if v.TapeBarcodePrefix == nil {
invalidParams.Add(smithy.NewErrParamRequired("TapeBarcodePrefix"))
}
if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpCreateTapeWithBarcodeInput(v *CreateTapeWithBarcodeInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateTapeWithBarcodeInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.TapeSizeInBytes == nil {
invalidParams.Add(smithy.NewErrParamRequired("TapeSizeInBytes"))
}
if v.TapeBarcode == nil {
invalidParams.Add(smithy.NewErrParamRequired("TapeBarcode"))
}
if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteAutomaticTapeCreationPolicyInput(v *DeleteAutomaticTapeCreationPolicyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteAutomaticTapeCreationPolicyInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteBandwidthRateLimitInput(v *DeleteBandwidthRateLimitInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteBandwidthRateLimitInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.BandwidthType == nil {
invalidParams.Add(smithy.NewErrParamRequired("BandwidthType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteCacheReportInput(v *DeleteCacheReportInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteCacheReportInput"}
if v.CacheReportARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("CacheReportARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteChapCredentialsInput(v *DeleteChapCredentialsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteChapCredentialsInput"}
if v.TargetARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("TargetARN"))
}
if v.InitiatorName == nil {
invalidParams.Add(smithy.NewErrParamRequired("InitiatorName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteFileShareInput(v *DeleteFileShareInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteFileShareInput"}
if v.FileShareARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("FileShareARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteGatewayInput(v *DeleteGatewayInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteGatewayInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteSnapshotScheduleInput(v *DeleteSnapshotScheduleInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteSnapshotScheduleInput"}
if v.VolumeARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("VolumeARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteTapeArchiveInput(v *DeleteTapeArchiveInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteTapeArchiveInput"}
if v.TapeARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteTapeInput(v *DeleteTapeInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteTapeInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.TapeARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteTapePoolInput(v *DeleteTapePoolInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteTapePoolInput"}
if v.PoolARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("PoolARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDeleteVolumeInput(v *DeleteVolumeInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DeleteVolumeInput"}
if v.VolumeARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("VolumeARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeAvailabilityMonitorTestInput(v *DescribeAvailabilityMonitorTestInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeAvailabilityMonitorTestInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeBandwidthRateLimitInput(v *DescribeBandwidthRateLimitInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeBandwidthRateLimitInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeBandwidthRateLimitScheduleInput(v *DescribeBandwidthRateLimitScheduleInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeBandwidthRateLimitScheduleInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeCachediSCSIVolumesInput(v *DescribeCachediSCSIVolumesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeCachediSCSIVolumesInput"}
if v.VolumeARNs == nil {
invalidParams.Add(smithy.NewErrParamRequired("VolumeARNs"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeCacheInput(v *DescribeCacheInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeCacheInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeCacheReportInput(v *DescribeCacheReportInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeCacheReportInput"}
if v.CacheReportARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("CacheReportARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeChapCredentialsInput(v *DescribeChapCredentialsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeChapCredentialsInput"}
if v.TargetARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("TargetARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeFileSystemAssociationsInput(v *DescribeFileSystemAssociationsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeFileSystemAssociationsInput"}
if v.FileSystemAssociationARNList == nil {
invalidParams.Add(smithy.NewErrParamRequired("FileSystemAssociationARNList"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeGatewayInformationInput(v *DescribeGatewayInformationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeGatewayInformationInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeMaintenanceStartTimeInput(v *DescribeMaintenanceStartTimeInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeMaintenanceStartTimeInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeNFSFileSharesInput(v *DescribeNFSFileSharesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeNFSFileSharesInput"}
if v.FileShareARNList == nil {
invalidParams.Add(smithy.NewErrParamRequired("FileShareARNList"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeSMBFileSharesInput(v *DescribeSMBFileSharesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeSMBFileSharesInput"}
if v.FileShareARNList == nil {
invalidParams.Add(smithy.NewErrParamRequired("FileShareARNList"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeSMBSettingsInput(v *DescribeSMBSettingsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeSMBSettingsInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeSnapshotScheduleInput(v *DescribeSnapshotScheduleInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeSnapshotScheduleInput"}
if v.VolumeARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("VolumeARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeStorediSCSIVolumesInput(v *DescribeStorediSCSIVolumesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeStorediSCSIVolumesInput"}
if v.VolumeARNs == nil {
invalidParams.Add(smithy.NewErrParamRequired("VolumeARNs"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeTapeRecoveryPointsInput(v *DescribeTapeRecoveryPointsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeTapeRecoveryPointsInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeTapesInput(v *DescribeTapesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeTapesInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeUploadBufferInput(v *DescribeUploadBufferInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeUploadBufferInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeVTLDevicesInput(v *DescribeVTLDevicesInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeVTLDevicesInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDescribeWorkingStorageInput(v *DescribeWorkingStorageInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DescribeWorkingStorageInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDetachVolumeInput(v *DetachVolumeInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DetachVolumeInput"}
if v.VolumeARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("VolumeARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDisableGatewayInput(v *DisableGatewayInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DisableGatewayInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpDisassociateFileSystemInput(v *DisassociateFileSystemInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "DisassociateFileSystemInput"}
if v.FileSystemAssociationARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("FileSystemAssociationARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpEvictFilesFailingUploadInput(v *EvictFilesFailingUploadInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "EvictFilesFailingUploadInput"}
if v.FileShareARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("FileShareARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpJoinDomainInput(v *JoinDomainInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "JoinDomainInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.DomainName == nil {
invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
}
if v.UserName == nil {
invalidParams.Add(smithy.NewErrParamRequired("UserName"))
}
if v.Password == nil {
invalidParams.Add(smithy.NewErrParamRequired("Password"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListLocalDisksInput(v *ListLocalDisksInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListLocalDisksInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
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 validateOpListVolumeInitiatorsInput(v *ListVolumeInitiatorsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListVolumeInitiatorsInput"}
if v.VolumeARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("VolumeARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpListVolumeRecoveryPointsInput(v *ListVolumeRecoveryPointsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ListVolumeRecoveryPointsInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpNotifyWhenUploadedInput(v *NotifyWhenUploadedInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "NotifyWhenUploadedInput"}
if v.FileShareARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("FileShareARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpRefreshCacheInput(v *RefreshCacheInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RefreshCacheInput"}
if v.FileShareARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("FileShareARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpRemoveTagsFromResourceInput(v *RemoveTagsFromResourceInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RemoveTagsFromResourceInput"}
if v.ResourceARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
}
if v.TagKeys == nil {
invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpResetCacheInput(v *ResetCacheInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ResetCacheInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpRetrieveTapeArchiveInput(v *RetrieveTapeArchiveInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RetrieveTapeArchiveInput"}
if v.TapeARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpRetrieveTapeRecoveryPointInput(v *RetrieveTapeRecoveryPointInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "RetrieveTapeRecoveryPointInput"}
if v.TapeARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpSetLocalConsolePasswordInput(v *SetLocalConsolePasswordInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SetLocalConsolePasswordInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.LocalConsolePassword == nil {
invalidParams.Add(smithy.NewErrParamRequired("LocalConsolePassword"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpSetSMBGuestPasswordInput(v *SetSMBGuestPasswordInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "SetSMBGuestPasswordInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.Password == nil {
invalidParams.Add(smithy.NewErrParamRequired("Password"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpShutdownGatewayInput(v *ShutdownGatewayInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "ShutdownGatewayInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartAvailabilityMonitorTestInput(v *StartAvailabilityMonitorTestInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartAvailabilityMonitorTestInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartCacheReportInput(v *StartCacheReportInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartCacheReportInput"}
if v.FileShareARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("FileShareARN"))
}
if v.Role == nil {
invalidParams.Add(smithy.NewErrParamRequired("Role"))
}
if v.LocationARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("LocationARN"))
}
if v.BucketRegion == nil {
invalidParams.Add(smithy.NewErrParamRequired("BucketRegion"))
}
if v.InclusionFilters != nil {
if err := validateCacheReportFilterList(v.InclusionFilters); err != nil {
invalidParams.AddNested("InclusionFilters", err.(smithy.InvalidParamsError))
}
}
if v.ExclusionFilters != nil {
if err := validateCacheReportFilterList(v.ExclusionFilters); err != nil {
invalidParams.AddNested("ExclusionFilters", err.(smithy.InvalidParamsError))
}
}
if v.ClientToken == nil {
invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
}
if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpStartGatewayInput(v *StartGatewayInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "StartGatewayInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateAutomaticTapeCreationPolicyInput(v *UpdateAutomaticTapeCreationPolicyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateAutomaticTapeCreationPolicyInput"}
if v.AutomaticTapeCreationRules == nil {
invalidParams.Add(smithy.NewErrParamRequired("AutomaticTapeCreationRules"))
} else if v.AutomaticTapeCreationRules != nil {
if err := validateAutomaticTapeCreationRules(v.AutomaticTapeCreationRules); err != nil {
invalidParams.AddNested("AutomaticTapeCreationRules", err.(smithy.InvalidParamsError))
}
}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateBandwidthRateLimitInput(v *UpdateBandwidthRateLimitInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateBandwidthRateLimitInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateBandwidthRateLimitScheduleInput(v *UpdateBandwidthRateLimitScheduleInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateBandwidthRateLimitScheduleInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.BandwidthRateLimitIntervals == nil {
invalidParams.Add(smithy.NewErrParamRequired("BandwidthRateLimitIntervals"))
} else if v.BandwidthRateLimitIntervals != nil {
if err := validateBandwidthRateLimitIntervals(v.BandwidthRateLimitIntervals); err != nil {
invalidParams.AddNested("BandwidthRateLimitIntervals", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateChapCredentialsInput(v *UpdateChapCredentialsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateChapCredentialsInput"}
if v.TargetARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("TargetARN"))
}
if v.SecretToAuthenticateInitiator == nil {
invalidParams.Add(smithy.NewErrParamRequired("SecretToAuthenticateInitiator"))
}
if v.InitiatorName == nil {
invalidParams.Add(smithy.NewErrParamRequired("InitiatorName"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateFileSystemAssociationInput(v *UpdateFileSystemAssociationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateFileSystemAssociationInput"}
if v.FileSystemAssociationARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("FileSystemAssociationARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateGatewayInformationInput(v *UpdateGatewayInformationInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateGatewayInformationInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateGatewaySoftwareNowInput(v *UpdateGatewaySoftwareNowInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateGatewaySoftwareNowInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateMaintenanceStartTimeInput(v *UpdateMaintenanceStartTimeInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateMaintenanceStartTimeInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateNFSFileShareInput(v *UpdateNFSFileShareInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateNFSFileShareInput"}
if v.FileShareARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("FileShareARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateSMBFileShareInput(v *UpdateSMBFileShareInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateSMBFileShareInput"}
if v.FileShareARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("FileShareARN"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateSMBFileShareVisibilityInput(v *UpdateSMBFileShareVisibilityInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateSMBFileShareVisibilityInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.FileSharesVisible == nil {
invalidParams.Add(smithy.NewErrParamRequired("FileSharesVisible"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateSMBLocalGroupsInput(v *UpdateSMBLocalGroupsInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateSMBLocalGroupsInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if v.SMBLocalGroups == nil {
invalidParams.Add(smithy.NewErrParamRequired("SMBLocalGroups"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateSMBSecurityStrategyInput(v *UpdateSMBSecurityStrategyInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateSMBSecurityStrategyInput"}
if v.GatewayARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
}
if len(v.SMBSecurityStrategy) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("SMBSecurityStrategy"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateSnapshotScheduleInput(v *UpdateSnapshotScheduleInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateSnapshotScheduleInput"}
if v.VolumeARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("VolumeARN"))
}
if v.StartAt == nil {
invalidParams.Add(smithy.NewErrParamRequired("StartAt"))
}
if v.RecurrenceInHours == nil {
invalidParams.Add(smithy.NewErrParamRequired("RecurrenceInHours"))
}
if v.Tags != nil {
if err := validateTags(v.Tags); err != nil {
invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
}
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}
func validateOpUpdateVTLDeviceTypeInput(v *UpdateVTLDeviceTypeInput) error {
if v == nil {
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "UpdateVTLDeviceTypeInput"}
if v.VTLDeviceARN == nil {
invalidParams.Add(smithy.NewErrParamRequired("VTLDeviceARN"))
}
if v.DeviceType == nil {
invalidParams.Add(smithy.NewErrParamRequired("DeviceType"))
}
if invalidParams.Len() > 0 {
return invalidParams
} else {
return nil
}
}