// Code generated by smithy-go-codegen DO NOT EDIT.

package iotfleetwise

import (
	"context"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/iotfleetwise/types"
	smithy "github.com/aws/smithy-go"
	"github.com/aws/smithy-go/middleware"
)

type validateOpAssociateVehicleFleet struct {
}

func (*validateOpAssociateVehicleFleet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAssociateVehicleFleet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AssociateVehicleFleetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAssociateVehicleFleetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpBatchCreateVehicle struct {
}

func (*validateOpBatchCreateVehicle) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpBatchCreateVehicle) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*BatchCreateVehicleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpBatchCreateVehicleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpBatchUpdateVehicle struct {
}

func (*validateOpBatchUpdateVehicle) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpBatchUpdateVehicle) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*BatchUpdateVehicleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpBatchUpdateVehicleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateCampaign struct {
}

func (*validateOpCreateCampaign) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateCampaign) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateCampaignInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateCampaignInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateDecoderManifest struct {
}

func (*validateOpCreateDecoderManifest) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateDecoderManifest) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateDecoderManifestInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateDecoderManifestInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateFleet struct {
}

func (*validateOpCreateFleet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateFleet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateFleetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateFleetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateModelManifest struct {
}

func (*validateOpCreateModelManifest) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateModelManifest) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateModelManifestInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateModelManifestInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateSignalCatalog struct {
}

func (*validateOpCreateSignalCatalog) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateSignalCatalog) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateSignalCatalogInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateSignalCatalogInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateVehicle struct {
}

func (*validateOpCreateVehicle) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateVehicle) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateVehicleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateVehicleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteCampaign struct {
}

func (*validateOpDeleteCampaign) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteCampaign) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteCampaignInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteCampaignInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteDecoderManifest struct {
}

func (*validateOpDeleteDecoderManifest) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteDecoderManifest) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteDecoderManifestInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteDecoderManifestInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteFleet struct {
}

func (*validateOpDeleteFleet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteFleet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteFleetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteFleetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteModelManifest struct {
}

func (*validateOpDeleteModelManifest) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteModelManifest) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteModelManifestInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteModelManifestInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteSignalCatalog struct {
}

func (*validateOpDeleteSignalCatalog) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteSignalCatalog) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteSignalCatalogInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteSignalCatalogInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteVehicle struct {
}

func (*validateOpDeleteVehicle) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteVehicle) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteVehicleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteVehicleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDisassociateVehicleFleet struct {
}

func (*validateOpDisassociateVehicleFleet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDisassociateVehicleFleet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DisassociateVehicleFleetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDisassociateVehicleFleetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetCampaign struct {
}

func (*validateOpGetCampaign) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetCampaign) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetCampaignInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetCampaignInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetDecoderManifest struct {
}

func (*validateOpGetDecoderManifest) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetDecoderManifest) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetDecoderManifestInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetDecoderManifestInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetFleet struct {
}

func (*validateOpGetFleet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetFleet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetFleetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetFleetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetModelManifest struct {
}

func (*validateOpGetModelManifest) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetModelManifest) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetModelManifestInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetModelManifestInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetSignalCatalog struct {
}

func (*validateOpGetSignalCatalog) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetSignalCatalog) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetSignalCatalogInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetSignalCatalogInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetVehicle struct {
}

func (*validateOpGetVehicle) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetVehicle) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetVehicleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetVehicleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetVehicleStatus struct {
}

func (*validateOpGetVehicleStatus) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetVehicleStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetVehicleStatusInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetVehicleStatusInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpImportDecoderManifest struct {
}

func (*validateOpImportDecoderManifest) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpImportDecoderManifest) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ImportDecoderManifestInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpImportDecoderManifestInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpImportSignalCatalog struct {
}

func (*validateOpImportSignalCatalog) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpImportSignalCatalog) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ImportSignalCatalogInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpImportSignalCatalogInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListDecoderManifestNetworkInterfaces struct {
}

func (*validateOpListDecoderManifestNetworkInterfaces) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListDecoderManifestNetworkInterfaces) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListDecoderManifestNetworkInterfacesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListDecoderManifestNetworkInterfacesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListDecoderManifestSignals struct {
}

func (*validateOpListDecoderManifestSignals) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListDecoderManifestSignals) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListDecoderManifestSignalsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListDecoderManifestSignalsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListFleetsForVehicle struct {
}

func (*validateOpListFleetsForVehicle) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListFleetsForVehicle) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListFleetsForVehicleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListFleetsForVehicleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListModelManifestNodes struct {
}

func (*validateOpListModelManifestNodes) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListModelManifestNodes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListModelManifestNodesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListModelManifestNodesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListSignalCatalogNodes struct {
}

func (*validateOpListSignalCatalogNodes) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListSignalCatalogNodes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListSignalCatalogNodesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListSignalCatalogNodesInput(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 validateOpListVehiclesInFleet struct {
}

func (*validateOpListVehiclesInFleet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListVehiclesInFleet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListVehiclesInFleetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListVehiclesInFleetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutLoggingOptions struct {
}

func (*validateOpPutLoggingOptions) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutLoggingOptions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutLoggingOptionsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutLoggingOptionsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRegisterAccount struct {
}

func (*validateOpRegisterAccount) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRegisterAccount) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RegisterAccountInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRegisterAccountInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpTagResource struct {
}

func (*validateOpTagResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*TagResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpTagResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUntagResource struct {
}

func (*validateOpUntagResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UntagResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUntagResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateCampaign struct {
}

func (*validateOpUpdateCampaign) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateCampaign) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateCampaignInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateCampaignInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateDecoderManifest struct {
}

func (*validateOpUpdateDecoderManifest) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateDecoderManifest) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateDecoderManifestInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateDecoderManifestInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateFleet struct {
}

func (*validateOpUpdateFleet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateFleet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateFleetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateFleetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateModelManifest struct {
}

func (*validateOpUpdateModelManifest) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateModelManifest) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateModelManifestInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateModelManifestInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateSignalCatalog struct {
}

func (*validateOpUpdateSignalCatalog) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateSignalCatalog) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateSignalCatalogInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateSignalCatalogInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateVehicle struct {
}

func (*validateOpUpdateVehicle) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateVehicle) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateVehicleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateVehicleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

func addOpAssociateVehicleFleetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateVehicleFleet{}, middleware.After)
}

func addOpBatchCreateVehicleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpBatchCreateVehicle{}, middleware.After)
}

func addOpBatchUpdateVehicleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpBatchUpdateVehicle{}, middleware.After)
}

func addOpCreateCampaignValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateCampaign{}, middleware.After)
}

func addOpCreateDecoderManifestValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateDecoderManifest{}, middleware.After)
}

func addOpCreateFleetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateFleet{}, middleware.After)
}

func addOpCreateModelManifestValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateModelManifest{}, middleware.After)
}

func addOpCreateSignalCatalogValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateSignalCatalog{}, middleware.After)
}

func addOpCreateVehicleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateVehicle{}, middleware.After)
}

func addOpDeleteCampaignValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteCampaign{}, middleware.After)
}

func addOpDeleteDecoderManifestValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteDecoderManifest{}, middleware.After)
}

func addOpDeleteFleetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteFleet{}, middleware.After)
}

func addOpDeleteModelManifestValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteModelManifest{}, middleware.After)
}

func addOpDeleteSignalCatalogValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteSignalCatalog{}, middleware.After)
}

func addOpDeleteVehicleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVehicle{}, middleware.After)
}

func addOpDisassociateVehicleFleetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateVehicleFleet{}, middleware.After)
}

func addOpGetCampaignValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetCampaign{}, middleware.After)
}

func addOpGetDecoderManifestValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetDecoderManifest{}, middleware.After)
}

func addOpGetFleetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetFleet{}, middleware.After)
}

func addOpGetModelManifestValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetModelManifest{}, middleware.After)
}

func addOpGetSignalCatalogValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetSignalCatalog{}, middleware.After)
}

func addOpGetVehicleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetVehicle{}, middleware.After)
}

func addOpGetVehicleStatusValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetVehicleStatus{}, middleware.After)
}

func addOpImportDecoderManifestValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpImportDecoderManifest{}, middleware.After)
}

func addOpImportSignalCatalogValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpImportSignalCatalog{}, middleware.After)
}

func addOpListDecoderManifestNetworkInterfacesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListDecoderManifestNetworkInterfaces{}, middleware.After)
}

func addOpListDecoderManifestSignalsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListDecoderManifestSignals{}, middleware.After)
}

func addOpListFleetsForVehicleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListFleetsForVehicle{}, middleware.After)
}

func addOpListModelManifestNodesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListModelManifestNodes{}, middleware.After)
}

func addOpListSignalCatalogNodesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListSignalCatalogNodes{}, middleware.After)
}

func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
}

func addOpListVehiclesInFleetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListVehiclesInFleet{}, middleware.After)
}

func addOpPutLoggingOptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutLoggingOptions{}, middleware.After)
}

func addOpRegisterAccountValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRegisterAccount{}, middleware.After)
}

func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
}

func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
}

func addOpUpdateCampaignValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateCampaign{}, middleware.After)
}

func addOpUpdateDecoderManifestValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateDecoderManifest{}, middleware.After)
}

func addOpUpdateFleetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateFleet{}, middleware.After)
}

func addOpUpdateModelManifestValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateModelManifest{}, middleware.After)
}

func addOpUpdateSignalCatalogValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateSignalCatalog{}, middleware.After)
}

func addOpUpdateVehicleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateVehicle{}, middleware.After)
}

func validateActuator(v *types.Actuator) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Actuator"}
	if v.FullyQualifiedName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FullyQualifiedName"))
	}
	if len(v.DataType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DataType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAttribute(v *types.Attribute) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Attribute"}
	if v.FullyQualifiedName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FullyQualifiedName"))
	}
	if len(v.DataType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DataType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBranch(v *types.Branch) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Branch"}
	if v.FullyQualifiedName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FullyQualifiedName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCanDbcDefinition(v *types.CanDbcDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CanDbcDefinition"}
	if v.NetworkInterface == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterface"))
	}
	if v.CanDbcFiles == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CanDbcFiles"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCanInterface(v *types.CanInterface) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CanInterface"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCanSignal(v *types.CanSignal) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CanSignal"}
	if v.Offset == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Offset"))
	}
	if v.Factor == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Factor"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCloudWatchLogDeliveryOptions(v *types.CloudWatchLogDeliveryOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CloudWatchLogDeliveryOptions"}
	if len(v.LogType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LogType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCollectionScheme(v types.CollectionScheme) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CollectionScheme"}
	switch uv := v.(type) {
	case *types.CollectionSchemeMemberConditionBasedCollectionScheme:
		if err := validateConditionBasedCollectionScheme(&uv.Value); err != nil {
			invalidParams.AddNested("[conditionBasedCollectionScheme]", err.(smithy.InvalidParamsError))
		}

	case *types.CollectionSchemeMemberTimeBasedCollectionScheme:
		if err := validateTimeBasedCollectionScheme(&uv.Value); err != nil {
			invalidParams.AddNested("[timeBasedCollectionScheme]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConditionBasedCollectionScheme(v *types.ConditionBasedCollectionScheme) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConditionBasedCollectionScheme"}
	if v.Expression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCreateVehicleRequestItem(v *types.CreateVehicleRequestItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVehicleRequestItem"}
	if v.VehicleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VehicleName"))
	}
	if v.ModelManifestArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelManifestArn"))
	}
	if v.DecoderManifestArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DecoderManifestArn"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCreateVehicleRequestItems(v []types.CreateVehicleRequestItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVehicleRequestItems"}
	for i := range v {
		if err := validateCreateVehicleRequestItem(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDataDestinationConfig(v types.DataDestinationConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataDestinationConfig"}
	switch uv := v.(type) {
	case *types.DataDestinationConfigMemberS3Config:
		if err := validateS3Config(&uv.Value); err != nil {
			invalidParams.AddNested("[s3Config]", err.(smithy.InvalidParamsError))
		}

	case *types.DataDestinationConfigMemberTimestreamConfig:
		if err := validateTimestreamConfig(&uv.Value); err != nil {
			invalidParams.AddNested("[timestreamConfig]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDataDestinationConfigs(v []types.DataDestinationConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataDestinationConfigs"}
	for i := range v {
		if err := validateDataDestinationConfig(v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateIamResources(v *types.IamResources) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IamResources"}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNetworkFileDefinition(v types.NetworkFileDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NetworkFileDefinition"}
	switch uv := v.(type) {
	case *types.NetworkFileDefinitionMemberCanDbc:
		if err := validateCanDbcDefinition(&uv.Value); err != nil {
			invalidParams.AddNested("[canDbc]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNetworkFileDefinitions(v []types.NetworkFileDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NetworkFileDefinitions"}
	for i := range v {
		if err := validateNetworkFileDefinition(v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNetworkInterface(v *types.NetworkInterface) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NetworkInterface"}
	if v.InterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InterfaceId"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.CanInterface != nil {
		if err := validateCanInterface(v.CanInterface); err != nil {
			invalidParams.AddNested("CanInterface", err.(smithy.InvalidParamsError))
		}
	}
	if v.ObdInterface != nil {
		if err := validateObdInterface(v.ObdInterface); err != nil {
			invalidParams.AddNested("ObdInterface", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNetworkInterfaces(v []types.NetworkInterface) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NetworkInterfaces"}
	for i := range v {
		if err := validateNetworkInterface(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNode(v types.Node) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Node"}
	switch uv := v.(type) {
	case *types.NodeMemberActuator:
		if err := validateActuator(&uv.Value); err != nil {
			invalidParams.AddNested("[actuator]", err.(smithy.InvalidParamsError))
		}

	case *types.NodeMemberAttribute:
		if err := validateAttribute(&uv.Value); err != nil {
			invalidParams.AddNested("[attribute]", err.(smithy.InvalidParamsError))
		}

	case *types.NodeMemberBranch:
		if err := validateBranch(&uv.Value); err != nil {
			invalidParams.AddNested("[branch]", err.(smithy.InvalidParamsError))
		}

	case *types.NodeMemberSensor:
		if err := validateSensor(&uv.Value); err != nil {
			invalidParams.AddNested("[sensor]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNodes(v []types.Node) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Nodes"}
	for i := range v {
		if err := validateNode(v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateObdInterface(v *types.ObdInterface) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ObdInterface"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateObdSignal(v *types.ObdSignal) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ObdSignal"}
	if v.Scaling == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Scaling"))
	}
	if v.Offset == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Offset"))
	}
	if v.ByteLength == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ByteLength"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3Config(v *types.S3Config) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3Config"}
	if v.BucketArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BucketArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSensor(v *types.Sensor) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Sensor"}
	if v.FullyQualifiedName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FullyQualifiedName"))
	}
	if len(v.DataType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DataType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSignalDecoder(v *types.SignalDecoder) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SignalDecoder"}
	if v.FullyQualifiedName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FullyQualifiedName"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.InterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InterfaceId"))
	}
	if v.CanSignal != nil {
		if err := validateCanSignal(v.CanSignal); err != nil {
			invalidParams.AddNested("CanSignal", err.(smithy.InvalidParamsError))
		}
	}
	if v.ObdSignal != nil {
		if err := validateObdSignal(v.ObdSignal); err != nil {
			invalidParams.AddNested("ObdSignal", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSignalDecoders(v []types.SignalDecoder) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SignalDecoders"}
	for i := range v {
		if err := validateSignalDecoder(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSignalInformation(v *types.SignalInformation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SignalInformation"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSignalInformationList(v []types.SignalInformation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SignalInformationList"}
	for i := range v {
		if err := validateSignalInformation(&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 validateTagList(v []types.Tag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
	for i := range v {
		if err := validateTag(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTimeBasedCollectionScheme(v *types.TimeBasedCollectionScheme) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TimeBasedCollectionScheme"}
	if v.PeriodMs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PeriodMs"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTimestreamConfig(v *types.TimestreamConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TimestreamConfig"}
	if v.TimestreamTableArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimestreamTableArn"))
	}
	if v.ExecutionRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExecutionRoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTimestreamResources(v *types.TimestreamResources) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TimestreamResources"}
	if v.TimestreamDatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimestreamDatabaseName"))
	}
	if v.TimestreamTableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimestreamTableName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateUpdateVehicleRequestItem(v *types.UpdateVehicleRequestItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateVehicleRequestItem"}
	if v.VehicleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VehicleName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateUpdateVehicleRequestItems(v []types.UpdateVehicleRequestItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateVehicleRequestItems"}
	for i := range v {
		if err := validateUpdateVehicleRequestItem(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateVehicleFleetInput(v *AssociateVehicleFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateVehicleFleetInput"}
	if v.VehicleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VehicleName"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchCreateVehicleInput(v *BatchCreateVehicleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchCreateVehicleInput"}
	if v.Vehicles == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Vehicles"))
	} else if v.Vehicles != nil {
		if err := validateCreateVehicleRequestItems(v.Vehicles); err != nil {
			invalidParams.AddNested("Vehicles", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchUpdateVehicleInput(v *BatchUpdateVehicleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdateVehicleInput"}
	if v.Vehicles == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Vehicles"))
	} else if v.Vehicles != nil {
		if err := validateUpdateVehicleRequestItems(v.Vehicles); err != nil {
			invalidParams.AddNested("Vehicles", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCampaignInput(v *CreateCampaignInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCampaignInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.SignalCatalogArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SignalCatalogArn"))
	}
	if v.TargetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetArn"))
	}
	if v.SignalsToCollect != nil {
		if err := validateSignalInformationList(v.SignalsToCollect); err != nil {
			invalidParams.AddNested("SignalsToCollect", err.(smithy.InvalidParamsError))
		}
	}
	if v.CollectionScheme == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollectionScheme"))
	} else if v.CollectionScheme != nil {
		if err := validateCollectionScheme(v.CollectionScheme); err != nil {
			invalidParams.AddNested("CollectionScheme", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataDestinationConfigs != nil {
		if err := validateDataDestinationConfigs(v.DataDestinationConfigs); err != nil {
			invalidParams.AddNested("DataDestinationConfigs", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDecoderManifestInput(v *CreateDecoderManifestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDecoderManifestInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ModelManifestArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelManifestArn"))
	}
	if v.SignalDecoders != nil {
		if err := validateSignalDecoders(v.SignalDecoders); err != nil {
			invalidParams.AddNested("SignalDecoders", err.(smithy.InvalidParamsError))
		}
	}
	if v.NetworkInterfaces != nil {
		if err := validateNetworkInterfaces(v.NetworkInterfaces); err != nil {
			invalidParams.AddNested("NetworkInterfaces", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFleetInput(v *CreateFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFleetInput"}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.SignalCatalogArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SignalCatalogArn"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateModelManifestInput(v *CreateModelManifestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateModelManifestInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Nodes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Nodes"))
	}
	if v.SignalCatalogArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SignalCatalogArn"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSignalCatalogInput(v *CreateSignalCatalogInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSignalCatalogInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Nodes != nil {
		if err := validateNodes(v.Nodes); err != nil {
			invalidParams.AddNested("Nodes", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVehicleInput(v *CreateVehicleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVehicleInput"}
	if v.VehicleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VehicleName"))
	}
	if v.ModelManifestArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelManifestArn"))
	}
	if v.DecoderManifestArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DecoderManifestArn"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteCampaignInput(v *DeleteCampaignInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteCampaignInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteDecoderManifestInput(v *DeleteDecoderManifestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDecoderManifestInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteFleetInput(v *DeleteFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteFleetInput"}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteModelManifestInput(v *DeleteModelManifestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteModelManifestInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteSignalCatalogInput(v *DeleteSignalCatalogInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteSignalCatalogInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteVehicleInput(v *DeleteVehicleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVehicleInput"}
	if v.VehicleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VehicleName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateVehicleFleetInput(v *DisassociateVehicleFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateVehicleFleetInput"}
	if v.VehicleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VehicleName"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCampaignInput(v *GetCampaignInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCampaignInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDecoderManifestInput(v *GetDecoderManifestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDecoderManifestInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetFleetInput(v *GetFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetFleetInput"}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetModelManifestInput(v *GetModelManifestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetModelManifestInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSignalCatalogInput(v *GetSignalCatalogInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSignalCatalogInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetVehicleInput(v *GetVehicleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetVehicleInput"}
	if v.VehicleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VehicleName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetVehicleStatusInput(v *GetVehicleStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetVehicleStatusInput"}
	if v.VehicleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VehicleName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpImportDecoderManifestInput(v *ImportDecoderManifestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportDecoderManifestInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.NetworkFileDefinitions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkFileDefinitions"))
	} else if v.NetworkFileDefinitions != nil {
		if err := validateNetworkFileDefinitions(v.NetworkFileDefinitions); err != nil {
			invalidParams.AddNested("NetworkFileDefinitions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpImportSignalCatalogInput(v *ImportSignalCatalogInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportSignalCatalogInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDecoderManifestNetworkInterfacesInput(v *ListDecoderManifestNetworkInterfacesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDecoderManifestNetworkInterfacesInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDecoderManifestSignalsInput(v *ListDecoderManifestSignalsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDecoderManifestSignalsInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListFleetsForVehicleInput(v *ListFleetsForVehicleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListFleetsForVehicleInput"}
	if v.VehicleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VehicleName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListModelManifestNodesInput(v *ListModelManifestNodesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListModelManifestNodesInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListSignalCatalogNodesInput(v *ListSignalCatalogNodesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListSignalCatalogNodesInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	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 validateOpListVehiclesInFleetInput(v *ListVehiclesInFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListVehiclesInFleetInput"}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutLoggingOptionsInput(v *PutLoggingOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutLoggingOptionsInput"}
	if v.CloudWatchLogDelivery == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CloudWatchLogDelivery"))
	} else if v.CloudWatchLogDelivery != nil {
		if err := validateCloudWatchLogDeliveryOptions(v.CloudWatchLogDelivery); err != nil {
			invalidParams.AddNested("CloudWatchLogDelivery", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRegisterAccountInput(v *RegisterAccountInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterAccountInput"}
	if v.TimestreamResources != nil {
		if err := validateTimestreamResources(v.TimestreamResources); err != nil {
			invalidParams.AddNested("TimestreamResources", err.(smithy.InvalidParamsError))
		}
	}
	if v.IamResources != nil {
		if err := validateIamResources(v.IamResources); err != nil {
			invalidParams.AddNested("IamResources", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTagResourceInput(v *TagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
	if v.ResourceARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	} else if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUntagResourceInput(v *UntagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
	if v.ResourceARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
	}
	if v.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateCampaignInput(v *UpdateCampaignInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCampaignInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDecoderManifestInput(v *UpdateDecoderManifestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDecoderManifestInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.SignalDecodersToAdd != nil {
		if err := validateSignalDecoders(v.SignalDecodersToAdd); err != nil {
			invalidParams.AddNested("SignalDecodersToAdd", err.(smithy.InvalidParamsError))
		}
	}
	if v.SignalDecodersToUpdate != nil {
		if err := validateSignalDecoders(v.SignalDecodersToUpdate); err != nil {
			invalidParams.AddNested("SignalDecodersToUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if v.NetworkInterfacesToAdd != nil {
		if err := validateNetworkInterfaces(v.NetworkInterfacesToAdd); err != nil {
			invalidParams.AddNested("NetworkInterfacesToAdd", err.(smithy.InvalidParamsError))
		}
	}
	if v.NetworkInterfacesToUpdate != nil {
		if err := validateNetworkInterfaces(v.NetworkInterfacesToUpdate); err != nil {
			invalidParams.AddNested("NetworkInterfacesToUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateFleetInput(v *UpdateFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFleetInput"}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateModelManifestInput(v *UpdateModelManifestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateModelManifestInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateSignalCatalogInput(v *UpdateSignalCatalogInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSignalCatalogInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.NodesToAdd != nil {
		if err := validateNodes(v.NodesToAdd); err != nil {
			invalidParams.AddNested("NodesToAdd", err.(smithy.InvalidParamsError))
		}
	}
	if v.NodesToUpdate != nil {
		if err := validateNodes(v.NodesToUpdate); err != nil {
			invalidParams.AddNested("NodesToUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateVehicleInput(v *UpdateVehicleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateVehicleInput"}
	if v.VehicleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VehicleName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}