// Validate inspects the fields of the type to determine if they are valid.
func (s *PutAttributesInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "PutAttributesInput"}
if s.Attributes == nil {
invalidParams.Add(request.NewErrParamRequired("Attributes"))
}
if s.DomainName == nil {
invalidParams.Add(request.NewErrParamRequired("DomainName"))
}
if s.ItemName == nil {
invalidParams.Add(request.NewErrParamRequired("ItemName"))
}
if s.Attributes != nil {
for i, v := range s.Attributes {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Attributes", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *WorkspaceRequest) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "WorkspaceRequest"}
if s.BundleId == nil {
invalidParams.Add(request.NewErrParamRequired("BundleId"))
}
if s.DirectoryId == nil {
invalidParams.Add(request.NewErrParamRequired("DirectoryId"))
}
if s.UserName == nil {
invalidParams.Add(request.NewErrParamRequired("UserName"))
}
if s.UserName != nil && len(*s.UserName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
}
if s.Tags != nil {
for i, v := range s.Tags {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *RemoveTagsFromCertificateInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "RemoveTagsFromCertificateInput"}
if s.CertificateArn == nil {
invalidParams.Add(request.NewErrParamRequired("CertificateArn"))
}
if s.CertificateArn != nil && len(*s.CertificateArn) < 20 {
invalidParams.Add(request.NewErrParamMinLen("CertificateArn", 20))
}
if s.Tags == nil {
invalidParams.Add(request.NewErrParamRequired("Tags"))
}
if s.Tags != nil && len(s.Tags) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Tags", 1))
}
if s.Tags != nil {
for i, v := range s.Tags {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *Event) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "Event"}
if s.EventType == nil {
invalidParams.Add(request.NewErrParamRequired("EventType"))
}
if s.EventType != nil && len(*s.EventType) < 1 {
invalidParams.Add(request.NewErrParamMinLen("EventType", 1))
}
if s.Timestamp == nil {
invalidParams.Add(request.NewErrParamRequired("Timestamp"))
}
if s.Version != nil && len(*s.Version) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Version", 1))
}
if s.Session != nil {
if err := s.Session.Validate(); err != nil {
invalidParams.AddNested("Session", err.(request.ErrInvalidParams))
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *PutScalingPolicyInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "PutScalingPolicyInput"}
if s.PolicyName == nil {
invalidParams.Add(request.NewErrParamRequired("PolicyName"))
}
if s.PolicyName != nil && len(*s.PolicyName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("PolicyName", 1))
}
if s.ResourceId == nil {
invalidParams.Add(request.NewErrParamRequired("ResourceId"))
}
if s.ResourceId != nil && len(*s.ResourceId) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ResourceId", 1))
}
if s.ScalableDimension == nil {
invalidParams.Add(request.NewErrParamRequired("ScalableDimension"))
}
if s.ServiceNamespace == nil {
invalidParams.Add(request.NewErrParamRequired("ServiceNamespace"))
}
if s.StepScalingPolicyConfiguration != nil {
if err := s.StepScalingPolicyConfiguration.Validate(); err != nil {
invalidParams.AddNested("StepScalingPolicyConfiguration", err.(request.ErrInvalidParams))
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *RequestCertificateInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "RequestCertificateInput"}
if s.DomainName == nil {
invalidParams.Add(request.NewErrParamRequired("DomainName"))
}
if s.DomainName != nil && len(*s.DomainName) < 1 {
invalidParams.Add(request.NewErrParamMinLen("DomainName", 1))
}
if s.DomainValidationOptions != nil && len(s.DomainValidationOptions) < 1 {
invalidParams.Add(request.NewErrParamMinLen("DomainValidationOptions", 1))
}
if s.IdempotencyToken != nil && len(*s.IdempotencyToken) < 1 {
invalidParams.Add(request.NewErrParamMinLen("IdempotencyToken", 1))
}
if s.SubjectAlternativeNames != nil && len(s.SubjectAlternativeNames) < 1 {
invalidParams.Add(request.NewErrParamMinLen("SubjectAlternativeNames", 1))
}
if s.DomainValidationOptions != nil {
for i, v := range s.DomainValidationOptions {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "DomainValidationOptions", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateTagsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "CreateTagsInput"}
if s.ResourceId == nil {
invalidParams.Add(request.NewErrParamRequired("ResourceId"))
}
if s.ResourceId != nil && len(*s.ResourceId) < 1 {
invalidParams.Add(request.NewErrParamMinLen("ResourceId", 1))
}
if s.Tags == nil {
invalidParams.Add(request.NewErrParamRequired("Tags"))
}
if s.Tags != nil {
for i, v := range s.Tags {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *PutTargetsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "PutTargetsInput"}
if s.Rule == nil {
invalidParams.Add(request.NewErrParamRequired("Rule"))
}
if s.Rule != nil && len(*s.Rule) < 1 {
invalidParams.Add(request.NewErrParamMinLen("Rule", 1))
}
if s.Targets == nil {
invalidParams.Add(request.NewErrParamRequired("Targets"))
}
if s.Targets != nil {
for i, v := range s.Targets {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Targets", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeTagsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DescribeTagsInput"}
if s.Filters != nil {
for i, v := range s.Filters {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Filters", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *StepScalingPolicyConfiguration) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "StepScalingPolicyConfiguration"}
if s.StepAdjustments != nil {
for i, v := range s.StepAdjustments {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "StepAdjustments", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *ListConfigurationsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "ListConfigurationsInput"}
if s.ConfigurationType == nil {
invalidParams.Add(request.NewErrParamRequired("ConfigurationType"))
}
if s.Filters != nil {
for i, v := range s.Filters {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Filters", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteTagsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeleteTagsInput"}
if s.ConfigurationIds == nil {
invalidParams.Add(request.NewErrParamRequired("ConfigurationIds"))
}
if s.Tags != nil {
for i, v := range s.Tags {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *DeletableItem) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "DeletableItem"}
if s.Name == nil {
invalidParams.Add(request.NewErrParamRequired("Name"))
}
if s.Attributes != nil {
for i, v := range s.Attributes {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Attributes", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *PutEventsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "PutEventsInput"}
if s.ClientContext == nil {
invalidParams.Add(request.NewErrParamRequired("ClientContext"))
}
if s.Events == nil {
invalidParams.Add(request.NewErrParamRequired("Events"))
}
if s.Events != nil {
for i, v := range s.Events {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Events", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *AddTagsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "AddTagsInput"}
if s.ARN == nil {
invalidParams.Add(request.NewErrParamRequired("ARN"))
}
if s.TagList == nil {
invalidParams.Add(request.NewErrParamRequired("TagList"))
}
if s.TagList != nil {
for i, v := range s.TagList {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "TagList", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *RebootWorkspacesInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "RebootWorkspacesInput"}
if s.RebootWorkspaceRequests == nil {
invalidParams.Add(request.NewErrParamRequired("RebootWorkspaceRequests"))
}
if s.RebootWorkspaceRequests != nil && len(s.RebootWorkspaceRequests) < 1 {
invalidParams.Add(request.NewErrParamMinLen("RebootWorkspaceRequests", 1))
}
if s.RebootWorkspaceRequests != nil {
for i, v := range s.RebootWorkspaceRequests {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "RebootWorkspaceRequests", i), err.(request.ErrInvalidParams))
}
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
func (s *StructShape) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "StructShape"}
if s.RequiredList == nil {
invalidParams.Add(request.NewErrParamRequired("RequiredList"))
}
if s.RequiredMap == nil {
invalidParams.Add(request.NewErrParamRequired("RequiredMap"))
}
if s.RequiredBool == nil {
invalidParams.Add(request.NewErrParamRequired("RequiredBool"))
}
if s.RequiredList != nil {
for i, v := range s.RequiredList {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "RequiredList", i), err.(request.ErrInvalidParams))
}
}
}
if s.RequiredMap != nil {
for i, v := range s.RequiredMap {
if v == nil {
continue
}
if err := v.Validate(); err != nil {
invalidParams.AddNested(fmt.Sprintf("%s[%v]", "RequiredMap", i), err.(request.ErrInvalidParams))
}
}
}
if s.OptionalStruct != nil {
if err := s.OptionalStruct.Validate(); err != nil {
invalidParams.AddNested("OptionalStruct", err.(request.ErrInvalidParams))
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}